Merge lp:~maddevelopers/mg5amcnlo/2.3.1_CMS into lp:~maddevelopers/mg5amcnlo/2.3.2

[Valentin Hirschi]

This branch implements the first full cross-checked implementation of the complex mass scheme.

The biggest part of the modification are related to the 2000+ lines implementation of the 'check cms' test, described in this wiki page:

https://cp3.irmp.ucl.ac.be/projects/madgraph/wiki/ComplexMassScheme

It is clear that this review doesn't need to pay attention to the actual implementation of the check as it is independent from the rest of MG5_aMC but it would be nice if we could have feedback on how intuitive and flexible the test is, and if you were successful at trying a couple processes.

This implementation doesn't lend itself well to unit tests, so the only two tests are the NLO one:
test_ML_check_cms_aem_emvevex
(slow but necessarily so)
and the leading order one
test_ML_check_cms_al_lvlvlx_LO
which together bring sufficient coverage.

There is some smaller modifications to the MG5_aMC core code as well, which might be worth having a quick glance at as well.

[lp:~maddevelopers/mg5amcnlo/2.3.1_CMS]

468. By Hua-Sheng Shao on 2015-08-14

1) delete several EW models and keep only two of them 2) fix a bug in _Gmu model

469. By Hua-Sheng Shao on 2015-08-14

change the acceptance test

470. By Valentin Hirschi on 2015-08-16

1. Merged with latest 2.3.2

[Olivier Mattelaer (olivier-mattelaer)]

will be for 2.3.3.

review: Disapprove

[lp:~maddevelopers/mg5amcnlo/2.3.1_CMS]

471. By Valentin Hirschi on 2015-09-30

1. Implemented changes according to Olivier's review comments.

472. By Valentin Hirschi on 2015-09-30

1. Implemented the second wave of Olivier's comment.

473. By Valentin Hirschi on 2015-09-30

1. Small typo in last commit

474. By Hua-Sheng Shao on 2015-10-01

fix a bug for QCD corrections when MB is non zero. It is harmless when MB = 0

475. By Valentin Hirschi on 2015-10-02

1. Merged with latest version of 2.3.3
2. Removed useless part of get_pole() function in the loop EW models

476. By Valentin Hirschi on 2015-10-09

1. Merged with latest 2.3.3.

477. By Valentin Hirschi on 2015-10-10

1. indentation issue

478. By Valentin Hirschi on 2015-10-12

1. Merged with the latest version of 2.3.3.

479. By Valentin Hirschi on 2015-10-13

1. Fixed last acceptance tests

480. By Valentin Hirschi on 2015-10-13

1. Merged with last version 2.3.3 and acceptance tests.

Unmerged revisions

480. By Valentin Hirschi on 2015-10-13

1. Merged with last version 2.3.3 and acceptance tests.

479. By Valentin Hirschi on 2015-10-13

1. Fixed last acceptance tests

478. By Valentin Hirschi on 2015-10-12

1. Merged with the latest version of 2.3.3.

477. By Valentin Hirschi on 2015-10-10

1. indentation issue

476. By Valentin Hirschi on 2015-10-09

1. Merged with latest 2.3.3.

475. By Valentin Hirschi on 2015-10-02

1. Merged with latest version of 2.3.3
2. Removed useless part of get_pole() function in the loop EW models

474. By Hua-Sheng Shao on 2015-10-01

fix a bug for QCD corrections when MB is non zero. It is harmless when MB = 0

473. By Valentin Hirschi on 2015-09-30

1. Small typo in last commit

472. By Valentin Hirschi on 2015-09-30

1. Implemented the second wave of Olivier's comment.

471. By Valentin Hirschi on 2015-09-30

1. Implemented changes according to Olivier's review comments.

=== modified file 'MadSpin/interface_madspin.py'
--- MadSpin/interface_madspin.py	2015-08-04 14:28:22 +0000
+++ MadSpin/interface_madspin.py	2015-08-16 06:06:34 +0000
@@ -923,12 +923,11 @@
         #base_model = import_ufo.import_model(model_path)
 
         # Import model
-        base_model = import_ufo.import_model(name, decay=True)
+        base_model = import_ufo.import_model(name, decay=True,
+                                               complex_mass_scheme=complex_mass)
 
         if use_mg_default:
             base_model.pass_particles_name_in_mg_default()
-        if complex_mass:
-            base_model.change_mass_to_complex_scheme()
         
         self.model = base_model
         self.mg5cmd._curr_model = self.model

=== modified file 'madgraph/core/base_objects.py'
--- madgraph/core/base_objects.py	2015-07-28 17:42:49 +0000
+++ madgraph/core/base_objects.py	2015-08-16 06:06:34 +0000
@@ -1547,9 +1547,9 @@
     def write_param_card(self):
         """Write out the param_card, and return as string."""
         
-        import models.write_param_card as writter
+        import models.write_param_card as writer
         out = StringIO.StringIO() # it's suppose to be written in a file
-        param = writter.ParamCardWriter(self)
+        param = writer.ParamCardWriter(self)
         param.define_output_file(out)
         param.write_card()
         return out.getvalue()
@@ -1577,55 +1577,118 @@
     def change_electroweak_mode(self, mode):
         """Change the electroweak mode. The only valid mode now is external.
         Where in top of the default MW and sw2 are external parameters."""
-        
-        assert mode == "external"
+
+        assert mode in ["external",set(['mz','mw','alpha'])]
         
         try:
             W = self.get('particle_dict')[24]
         except KeyError:
-            raise InvalidCmd('No W particle in the model impossible to change the EW scheme!')
+            raise InvalidCmd('No W particle in the model impossible to '+
+                                                        'change the EW scheme!')
         
-        MW = self.get_parameter(W.get('mass'))
-        if not isinstance(MW, ParamCardVariable):
-            newMW = ParamCardVariable(MW.name, MW.value, 'MASS', [24])
-            if not newMW.value:
-                newMW.value = 80.385
-            #remove the old definition
-            self.get('parameters')[MW.depend].remove(MW)
-            # add the new one
-            self.add_param(newMW, ['external'])
-            
-        # Now check for sw2. if not define bypass this
-        try:
-            sw2 = self.get_parameter('sw2')
-        except KeyError:
+        if mode=='external':
+            MW = self.get_parameter(W.get('mass'))
+            if not isinstance(MW, ParamCardVariable):
+                newMW = ParamCardVariable(MW.name, MW.value, 'MASS', [24])
+                if not newMW.value:
+                    newMW.value = 80.385
+                #remove the old definition
+                self.get('parameters')[MW.depend].remove(MW)
+                # add the new one
+                self.add_param(newMW, ['external'])
+                
+            # Now check for sw2. if not define bypass this
             try:
-                sw2 = self.get_parameter('mdl_sw2')
+                sw2 = self.get_parameter('sw2')
             except KeyError:
-                sw2=None
-        
-        if sw2:
-            newsw2 = ParamCardVariable(sw2.name,sw2.value, 'SMINPUTS', [4])
-            if not newsw2.value:
-                newsw2.value = 0.222246485786
-            #remove the old definition
-            self.get('parameters')[sw2.depend].remove(sw2)
-            # add the new one
-            self.add_param(newsw2, ['external'])            
-
-    def change_mass_to_complex_scheme(self):
+                try:
+                    sw2 = self.get_parameter('mdl_sw2')
+                except KeyError:
+                    sw2=None
+    
+            if sw2:
+                newsw2 = ParamCardVariable(sw2.name,sw2.value, 'SMINPUTS', [4])
+                if not newsw2.value:
+                    newsw2.value = 0.222246485786
+                #remove the old definition
+                self.get('parameters')[sw2.depend].remove(sw2)
+                # add the new one
+                self.add_param(newsw2, ['external'])
+            # Force a refresh of the parameter dictionary
+            self.parameters_dict = None
+            return true
+
+        elif mode==set(['mz','mw','alpha']):
+            # For now, all we support is to go from mz, Gf, alpha to mz, mw, alpha
+            W = self.get('particle_dict')[24]
+            mass = self.get_parameter(W.get('mass'))
+            mass_expr = 'cmath.sqrt(%(prefix)sMZ__exp__2/2. + cmath.sqrt('+\
+              '%(prefix)sMZ__exp__4/4. - (%(prefix)saEW*cmath.pi*%(prefix)s'+\
+              'MZ__exp__2)/(%(prefix)sGf*%(prefix)ssqrt__2)))'
+            if 'external' in mass.depend:
+                # Nothing to be done
+                return True
+            match = False
+            if mass.expr == mass_expr%{'prefix':''}:
+                prefix = ''
+                match = True
+            elif mass.expr == mass_expr%{'prefix':'mdl_'}:
+                prefix = 'mdl_'
+                match = True
+            if match:
+                MW = ParamCardVariable(mass.name, mass.value, 'MASS', [24])
+                if not MW.value:
+                    MW.value = 80.385                
+                self.get('parameters')[('external',)].append(MW)
+                self.get('parameters')[mass.depend].remove(mass)
+                # Make Gf an internal parameter
+                new_param = ModelVariable('Gf',
+                '-%(prefix)saEW*%(prefix)sMZ**2*cmath.pi/(cmath.sqrt(2)*%(MW)s**2*(%(MW)s**2 - %(prefix)sMZ**2))' %\
+                {'MW': mass.name,'prefix':prefix}, 'complex', mass.depend)
+                Gf = self.get_parameter('%sGf'%prefix)
+                self.get('parameters')[('external',)].remove(Gf)
+                self.add_param(new_param, ['%saEW'%prefix])
+                # Force a refresh of the parameter dictionary
+                self.parameters_dict = None
+                return True
+            else:
+                return False
+
+    def change_mass_to_complex_scheme(self, toCMS=True):
         """modify the expression changing the mass to complex mass scheme"""
         
-        # 1) Find All input parameter mass and width associated
+        # 1) Change the 'CMSParam' of loop_qcd_qed model to 1.0 so as to remove
+        #    the 'real' prefix fromall UVCT wf renormalization expressions.
+        #    If toCMS is False, then it makes sure CMSParam is 0.0 and returns
+        #    immediatly.
+        # 2) Find All input parameter mass and width associated
         #   Add a internal parameter and replace mass with that param
-        # 2) Find All mass fixed by the model and width associated
+        # 3) Find All mass fixed by the model and width associated
         #   -> Both need to be fixed with a real() /Imag()
-        # 3) Find All width fixed by the model
-        #   -> Need to be fixed with a real()
-        # 4) Fix the Yukawa mass to the value of the complex mass/ real mass
-        # 5) Loop through all expression and modify those accordingly
+        # 4) Find All width set by the model
+        #   -> Need to be set with a real()
+        # 5) Fix the Yukawa mass to the value of the complex mass/ real mass
+        # 6) Loop through all expression and modify those accordingly
         #    Including all parameter expression as complex
-
+        
+        try:
+            CMSParam = self.get_parameter('CMSParam')
+        except KeyError:
+            try:
+                CMSParam = self.get_parameter('mdl_CMSParam')
+            except KeyError:
+                CMSParam = None
+                
+        # Handle the case where we want to make sure the CMS is turned off
+        if not toCMS:
+            if CMSParam:
+                CMSParam.expr = '0.0'
+            return            
+        
+        # Now handle the case where we want to turn to CMS.    
+        if CMSParam:
+            CMSParam.expr = '1.0'
+        
         to_change = {}
         mass_widths = [] # parameter which should stay real
         for particle in self.get('particles'):
@@ -1634,52 +1697,29 @@
                 continue
             mass_widths.append(particle.get('width'))
             mass_widths.append(particle.get('mass'))
-            if particle.get('width') == 'ZERO':
+            width = self.get_parameter(particle.get('width'))
+            if (isinstance(width.value, (complex,float)) and abs(width.value)==0.0) or \
+                                                    width.name.lower() =='zero':
                 #everything is fine since the width is zero
                 continue
-            width = self.get_parameter(particle.get('width'))
             if not isinstance(width, ParamCardVariable):
                 width.expr = 're(%s)' % width.expr
-            if particle.get('mass') != 'ZERO':
-                mass = self.get_parameter(particle.get('mass'))
+            mass = self.get_parameter(particle.get('mass'))
+            if (isinstance(width.value, (complex,float)) and abs(width.value)!=0.0) or \
+                                                    mass.name.lower() != 'zero':
                 # special SM treatment to change the gauge scheme automatically.
-                if particle.get('pdg_code') == 24:
-                    if hasattr(mass, 'expr') and mass.expr == 'cmath.sqrt(MZ__exp__2/2. + cmath.sqrt(MZ__exp__4/4. - (aEW*cmath.pi*MZ__exp__2)/(Gf*sqrt__2)))':
-                        # Make MW an external parameter
-                        MW = ParamCardVariable(mass.name, mass.value, 'MASS', [24])
-                        if not MW.value:
-                            MW.value = 80.385
-                        self.get('parameters')[('external',)].append(MW)
-                        self.get('parameters')[mass.depend].remove(mass)
-                        # Make Gf an internal parameter
-                        new_param = ModelVariable('Gf',
-                        '-aEW*MZ**2*cmath.pi/(cmath.sqrt(2)*%(MW)s**2*(%(MW)s**2 - MZ**2))' %\
-                        {'MW': mass.name}, 'complex', mass.depend)
-                        Gf = self.get_parameter('Gf')
-                        self.get('parameters')[('external',)].remove(Gf)
-                        self.add_param(new_param, ['aEW'])
-                        # Use the new mass for the future modification
-                        mass = MW
-                    #option with prefixing
-                    elif hasattr(mass, 'expr') and mass.expr == 'cmath.sqrt(mdl_MZ__exp__2/2. + cmath.sqrt(mdl_MZ__exp__4/4. - (mdl_aEW*cmath.pi*mdl_MZ__exp__2)/(mdl_Gf*mdl_sqrt__2)))':
-                        # Make MW an external parameter
-                        MW = ParamCardVariable(mass.name, mass.value, 'MASS', [24])
-                        if not MW.value:
-                            MW.value = 80.385
-                        self.get('parameters')[('external',)].append(MW)
-                        self.get('parameters')[mass.depend].remove(mass)
-                        # Make Gf an internal parameter
-                        new_param = ModelVariable('mdl_Gf',
-                        '-mdl_aEW*mdl_MZ**2*cmath.pi/(cmath.sqrt(2)*%(MW)s**2*(%(MW)s**2 - mdl_MZ**2))' %\
-                        {'MW': mass.name}, 'complex', mass.depend)
-                        Gf = self.get_parameter('mdl_Gf')
-                        self.get('parameters')[('external',)].remove(Gf)
-                        self.add_param(new_param, ['mdl_aEW'])
-                        # Use the new mass for the future modification
-                        mass = MW
-                    elif isinstance(mass, ModelVariable):
-                        logger.warning('W mass is not an external parameter. This is not adviced for the complex mass scheme.')
-                
+                if particle.get('pdg_code') == 24 and isinstance(mass, 
+                                                                 ModelVariable):
+                    status = self.change_electroweak_mode(
+                                                   set(['mz','mw','alpha']))
+                    # Use the newly defined parameter for the W mass
+                    mass = self.get_parameter(particle.get('mass'))
+                    if not status:
+                        logger.warning('The W mass is not an external '+
+                        'parameter in this model and the automatic change of'+
+                        ' electroweak scheme changed. This is not advised for '+
+                                            'applying the complex mass scheme.')
+
                 # Add A new parameter CMASS
                 #first compute the dependencies (as,...)
                 depend = list(set(mass.depend + width.depend))
@@ -3638,7 +3678,7 @@
         my_isids = [leg.get('ids') for leg in self.get('legs') \
               if not leg.get('state')]
         my_fsids = [leg.get('ids') for leg in self.get('legs') \
-             if leg.get('state')]
+             if leg.get('state')]            
         for i, is_id in enumerate(initial_state_ids):
             assert is_id in my_isids[i]
         for i, fs_id in enumerate(final_state_ids):

=== modified file 'madgraph/core/helas_objects.py'
--- madgraph/core/helas_objects.py	2015-07-02 02:29:22 +0000
+++ madgraph/core/helas_objects.py	2015-08-16 06:06:34 +0000
@@ -3164,7 +3164,7 @@
         """Calculate the actual coupling orders of this diagram"""
 
         wavefunctions = HelasWavefunctionList.extract_wavefunctions(\
-            self.get('amplitudes')[0].get('mothers'))
+                                       self.get('amplitudes')[0].get('mothers'))
 
         coupling_orders = {}
         for wf in wavefunctions + [self.get('amplitudes')[0]]:

=== modified file 'madgraph/interface/common_run_interface.py'
--- madgraph/interface/common_run_interface.py	2015-07-30 14:26:07 +0000
+++ madgraph/interface/common_run_interface.py	2015-08-16 06:06:34 +0000
@@ -221,19 +221,17 @@
             #restrict_file = None
             #if os.path.exists(pjoin(ufo_path, 'restrict_default.dat')):
             #    restrict_file = pjoin(ufo_path, 'restrict_default.dat')
+            
+            force_CMS = self.mother and self.mother.options['complex_mass_scheme']
             model = import_ufo.import_model(modelname, decay=True, 
-                        restrict=True)
-            if self.mother and self.mother.options['complex_mass_scheme']:
-                model.change_mass_to_complex_scheme()
+                                   restrict=True, complex_mass_scheme=force_CMS)
         else:
-            model = import_ufo.import_model(pjoin(
-                           self.me_dir,'bin','internal', 'ufomodel'),decay=True)
             #pattern for checking complex mass scheme.
             has_cms = re.compile(r'''set\s+complex_mass_scheme\s*(True|T|1|true|$|;)''')
-            if has_cms.search(open(pjoin(self.me_dir,'Cards','proc_card_mg5.dat')\
-                                   ).read()):
-                model.change_mass_to_complex_scheme()
-   
+            force_CMS =  has_cms.search(open(pjoin(self.me_dir,'Cards',
+                                                   'proc_card_mg5.dat')).read())
+            model = import_ufo.import_model(pjoin(self.me_dir,'bin','internal',
+                         'ufomodel'), decay=True, complex_mass_scheme=force_CMS)
             
 #        if not hasattr(model.get('particles')[0], 'partial_widths'):
 #            raise self.InvalidCmd, 'The UFO model does not include partial widths information. Impossible to compute widths automatically'
@@ -2219,6 +2217,53 @@
                         'fixed_scale': ['run_card fixed_fac_scale T', 'run_card fixed_ren_scale T', 'run_card scale %(0)s', 'run_card dsqrt_q2fact1 %(0)s' ,'run_card dsqrt_q2fact2 %(0)s'],
                         }
     
+    @staticmethod
+    def analyze_param_card(param_card):
+        """ Analyzes the comment of the parameter in the param_card and returns
+        a dictionary with parameter names in values and the tuple (lhablock, id)
+        in value as well as a dictionary for restricted values."""
+    
+        pname2block = {}
+        restricted_value = {}
+
+        for bname, block in param_card.items():
+            for lha_id, param in block.param_dict.items():
+                all_var = []
+                comment = param.comment
+                # treat merge parameter
+                if comment.strip().startswith('set of param :'):
+                    all_var = list(re.findall(r'''[^-]1\*(\w*)\b''', comment))
+                # just the variable name as comment
+                elif len(comment.split()) == 1:
+                    all_var = [comment.strip().lower()]
+                # either contraction or not formatted
+                else:
+                    split = comment.split()
+                    if len(split) >2 and split[1] == ':':
+                        # NO VAR associated
+                        restricted_value[(bname, lha_id)] = ' '.join(split[1:])
+                    elif len(split) == 2:
+                        if re.search(r'''\[[A-Z]\]eV\^''', split[1]):
+                            all_var = [comment.strip().lower()]
+                    elif len(split) >=2 and split[1].startswith('('):
+                        all_var = [split[0].strip().lower()]
+                    else:
+                        if not bname.startswith('qnumbers'):
+                            logger.debug("not recognize information for %s %s : %s",
+                                      bname, lha_id, comment)
+                        # not recognized format
+                        continue
+
+                for var in all_var:
+                    var = var.lower()
+                    if var in pname2block:
+                        pname2block[var].append((bname, lha_id))
+                    else:
+                        pname2block[var] = [(bname, lha_id)]
+        
+        return pname2block, restricted_value
+
+    
     def __init__(self, question, cards=[], mode='auto', *args, **opt):
 
         # Initiation
@@ -2263,40 +2308,8 @@
         # Read the comment of the param_card_default to find name variable for
         # the param_card also check which value seems to be constrained in the
         # model.
-        for bname, block in default_param.items():
-            for lha_id, param in block.param_dict.items():
-                all_var = []
-                comment = param.comment
-                # treat merge parameter
-                if comment.strip().startswith('set of param :'):
-                    all_var = list(re.findall(r'''[^-]1\*(\w*)\b''', comment))
-                # just the variable name as comment
-                elif len(comment.split()) == 1:
-                    all_var = [comment.strip().lower()]
-                # either contraction or not formatted
-                else:
-                    split = comment.split()
-                    if len(split) >2 and split[1] == ':':
-                        # NO VAR associated
-                        self.restricted_value[(bname, lha_id)] = ' '.join(split[1:])
-                    elif len(split) == 2:
-                        if re.search(r'''\[[A-Z]\]eV\^''', split[1]):
-                            all_var = [comment.strip().lower()]
-                    elif len(split) >=2 and split[1].startswith('('):
-                        all_var = [split[0].strip().lower()]
-                    else:
-                        if not bname.startswith('qnumbers'):
-                            logger.debug("not recognize information for %s %s : %s",
-                                      bname, lha_id, comment)
-                        # not recognized format
-                        continue
-
-                for var in all_var:
-                    var = var.lower()
-                    if var in self.pname2block:
-                        self.pname2block[var].append((bname, lha_id))
-                    else:
-                        self.pname2block[var] = [(bname, lha_id)]
+        self.pname2block, self.restricted_value = self.analyze_param_card(
+                                                                  default_param)
 
         if run_card_def:
             self.run_set = run_card_def.keys() + self.run_card.hidden_param

=== modified file 'madgraph/interface/loop_interface.py'
--- madgraph/interface/loop_interface.py	2015-07-20 20:38:46 +0000
+++ madgraph/interface/loop_interface.py	2015-08-16 06:06:34 +0000
@@ -227,7 +227,8 @@
 #                                  "\nIt is however a straight-forward extension which "+\
 #                                  "will come out with the next release.")                           
 
-        if isinstance(proc, base_objects.ProcessDefinition) and mode.startswith('ML5'):
+        if isinstance(proc, base_objects.ProcessDefinition) and mode.startswith('ML5') \
+                                                   and not mode.endswith('cms'):
             if proc.has_multiparticle_label():
                 raise self.InvalidCmd(
                   "When running ML5 standalone, multiparticle labels cannot be"+\
@@ -665,7 +666,8 @@
         # Now make sure the process is acceptable
         proc = " ".join(argss[1:i+1])
         myprocdef = self.extract_process(proc)
-        self.proc_validity(myprocdef,'ML5_check')
+        self.proc_validity(myprocdef,'ML5_check_cms' if argss[0]=='cms' else \
+                                                                    'ML5_check')
         
         return mg_interface.MadGraphCmd.do_check(self, line, *args,**opt)
     

=== modified file 'madgraph/interface/madevent_interface.py'
--- madgraph/interface/madevent_interface.py	2015-08-15 21:40:38 +0000
+++ madgraph/interface/madevent_interface.py	2015-08-16 06:06:34 +0000
@@ -4951,7 +4951,7 @@
                 req_files.remove('HelFilter.dat')
             except ValueError:
                 pass
-
+        
         for v_folder in glob.iglob(pjoin(proc_dir,'SubProcesses',
                                                          '%s*'%subproc_prefix)):        
             # Make sure it is a valid MadLoop directory

=== modified file 'madgraph/interface/madgraph_interface.py'
--- madgraph/interface/madgraph_interface.py	2015-08-11 11:20:19 +0000
+++ madgraph/interface/madgraph_interface.py	2015-08-16 06:06:34 +0000
@@ -474,6 +474,37 @@
         logger.info("o lorentz_invariance:",'$MG:color:GREEN')
         logger.info("   Check that the amplitude is lorentz invariant by")
         logger.info("   comparing the amplitiude in different frames")
+        logger.info("o cms:",'$MG:color:GREEN')
+        logger.info("   Check the complex mass scheme consistency by comparing")
+        logger.info("   it to the narrow width approximation in the off-shell")
+        logger.info("   region of detected resonances and by progressively")
+        logger.info("   decreasing the width. Additional options for this check are:")
+        logger.info("    --offshellness=f : f is a positive or negative float specifying ")
+        logger.info("      the distance from the pole as f*particle_mass. Default is 10.0")
+        logger.info("    --seed=i : to force a specific RNG integer seed i (default is fixed to 0)")
+        logger.info("    --cms=order1&order2;...,p1->f(p,lambdaCMS)&p2->f2(p,lambdaCMS);...")
+        logger.info("      'order_i' specifies the expansion orders considered for the test.")
+        logger.info("      The substitution lists specifies how internal parameter must be modified")
+        logger.info("      with the width scaling 'lambdaCMS'. The default value for this option is:")
+        logger.info("        --cms=QED&QCD,aewm1->10.0/lambdaCMS&as->0.1*lambdaCMS ")
+        logger.info("      The number of order and parameters don't have to be the same.")
+        logger.info("      The scaling must be specified so that one occurrence of the coupling order.")
+        logger.info("      brings in exactly one power of lambdaCMS.")
+        logger.info("    --recompute_width= never|first_time|always|auto")
+        logger.info("      Decides when to use MadWidth to automatically recompute the width")
+        logger.info("      'auto' (default) let MG5 chose the most appropriate behavior.")
+        logger.info("      'never' uses the default width value for lambdaCMS=1.0.")
+        logger.info("      'first_time' uses MadWidth to compute the width for lambdaCMS=1.0.")
+        logger.info("      'first_time' and 'never' assume linear scaling of the widths with lambdaCMS")
+        logger.info("      'always' uses MadWidth to compute the widths for all values of lambdaCMS")
+        logger.info("               the test relies on linear scaling of the width, so 'always' is ")
+        logger.info("               only for double-checks")
+        logger.info("    --lambdaCMS = <python_list> : specifies the list of lambdaCMS values to ")
+        logger.info("      use for the test. For example: '[(1/2.0)**exp\ for\ exp\ in\ range(0,20)]'")
+        logger.info("      In the list expression, you must escape spaces. Also, this option")
+        logger.info("      *must* appear last in the otpion list. Finally, the default value is '1.0e-6'")
+        logger.info("      for which an optimal list of progressive values is picked up to 1.0e-6")
+        logger.info("    --show_plot = True or False: Whether to show plot during analysis (default is True)")
         logger.info("Comments",'$MG:color:GREEN')
         logger.info(" > If param_card is given, that param_card is used ")
         logger.info("   instead of the default values for the model.")
@@ -836,15 +867,17 @@
             raise self.InvalidCmd(\
                 "\"check\" not possible for v4 models")
 
-        if len(args) < 2:
+        if len(args) < 2 and not args[0].lower().endswith('options'):
             self.help_check()
             raise self.InvalidCmd("\"check\" requires a process.")
 
-        if args[0] not in self._check_opts:
+        if args[0] not in self._check_opts and \
+                                        not args[0].lower().endswith('options'):
             args.insert(0, 'full')
 
         param_card = None
-        if args[0] not in ['stability','profile','timing'] and os.path.isfile(args[1]):
+        if args[0] not in ['stability','profile','timing'] and \
+                                        len(args)>1 and os.path.isfile(args[1]):
             param_card = args.pop(1)
 
         if len(args)>1:
@@ -853,9 +886,8 @@
         else:
             args.append('-no_reuse')
 
-        if args[0] in ['timing'] and os.path.isfile(args[2]):
+        if args[0] in ['timing'] and len(args)>2 and os.path.isfile(args[2]):
             param_card = args.pop(2)
-            misc.sprint(param_card)
         if args[0] in ['stability', 'profile'] and len(args)>1:
             # If the first argument after 'stability' is not the integer
             # specifying the desired statistics (i.e. number of points), then
@@ -867,21 +899,73 @@
 
         if args[0] in ['stability', 'profile'] and os.path.isfile(args[3]):
             param_card = args.pop(3)
-
-        if any([',' in elem for elem in args]):
+        if any([',' in elem for elem in args if not elem.startswith('--')]):
             raise self.InvalidCmd('Decay chains not allowed in check')
         
         user_options = {'--energy':'1000','--split_orders':'-1',
-                                                       '--reduction':'1|2|3|4'}
+                   '--reduction':'1|2|3|4','--CTModeRun':'-1','--helicity':'-1'}
+        
+        if args[0] in ['cms'] or args[0].lower()=='cmsoptions':
+            # increase the default energy to 5000
+            user_options['--energy']='5000'
+            # The first argument gives the name of the coupling order in which
+            # the cms expansion is carried, and the expression following the 
+            # comma gives the relation of an external parameter with the
+            # CMS expansions parameter called 'lambdaCMS'.
+            parameters = ['aewm1->10.0/lambdaCMS','as->0.1*lambdaCMS']
+            user_options['--cms']='QED&QCD,'+'&'.join(parameters)
+            # Widths are assumed to scale linearly with lambdaCMS unless
+            # --force_recompute_width='always' or 'first_time' is used.
+            user_options['--recompute_width']='auto'
+            # It can be negative so as to be offshell below the resonant mass
+            user_options['--offshellness']='10.0'
+            # Pick the lambdaCMS values for the test. Instead of a python list
+            # we specify here (low,N) which means that do_check will automatically
+            # pick lambda values up to the value low and with N values uniformly
+            # spread in each interval [1.0e-i,1.0e-(i+1)].
+            # Some points close to each other will be added at the end for the
+            # stability test.
+            user_options['--lambdaCMS']='(1.0e-6,5)'
+            # Set the RNG seed, -1 is default (random).
+            user_options['--seed']=666
+            # The option below can help the user re-analyze existing pickled check
+            user_options['--analyze']='None'
+            # Decides whether to show plot or not during the analysis
+            user_options['--show_plot']='True'
+            # 'secret' option to chose by which lambda power one should divide
+            # the nwa-cms difference. Useful to set to 2 when doing the Born check
+            # to see whether the NLO check will have sensitivity to the CMS
+            # implementation
+            user_options['--diff_lambda_power']='1'
+            # Sets the range of lambda values to plot
+            user_options['--lambda_plot_range']='[-1.0,-1.0]'
+            # Sets a filter to apply at generation. See name of available 
+            # filters in loop_diagram_generations.py, function user_filter 
+            user_options['--loop_filter']='None'
+            # Apply tweaks to the check like multiplying a certain width by a
+            # certain parameters or changing the analytical continuation of the 
+            # logarithms of the UV counterterms
+            user_options['--tweak']='default()'
+            # Give a name to the run for the files to be saved
+            user_options['--name']='auto'
+            # Select what resonances must be run
+            user_options['--resonances']='1'
         for arg in args[:]:
             if arg.startswith('--') and '=' in arg:
-                key, value = arg.split('=')
+                parsed = arg.split('=')
+                key, value = parsed[0],'='.join(parsed[1:])
                 if key not in user_options:
                     raise self.InvalidCmd, "unknown option %s" % key
                 user_options[key] = value
                 args.remove(arg)
 
-        self.check_process_format(" ".join(args[1:]))
+        # If we are just re-analyzing saved data or displaying options then we 
+        # shouldn't check the process format.
+        if not (args[0]=='cms' and '--analyze' in user_options and \
+                              user_options['--analyze']!='None') and not \
+                                            args[0].lower().endswith('options'):
+            
+            self.check_process_format(" ".join(args[1:]))
 
         for option, value in user_options.items():
             args.append('%s=%s'%(option,value))
@@ -2448,7 +2532,7 @@
     _tutorial_opts = ['aMCatNLO', 'stop', 'MadLoop', 'MadGraph5']
     _switch_opts = ['mg5','aMC@NLO','ML5']
     _check_opts = ['full', 'timing', 'stability', 'profile', 'permutation',
-                   'gauge','lorentz', 'brs']
+                   'gauge','lorentz', 'brs', 'cms']
     _import_formats = ['model_v4', 'model', 'proc_v4', 'command', 'banner']
     _install_opts = ['pythia-pgs', 'Delphes', 'MadAnalysis', 'ExRootAnalysis',
                      'update', 'Delphes2', 'SysCalc', 'Golem95']
@@ -3233,10 +3317,37 @@
     # Perform checks
     def do_check(self, line):
         """Check a given process or set of processes"""
+        
+        ###### BEGIN do_check
+        def create_lambda_values_list(lower_bound, N):
+            """ Returns a list of values spanning the range [1.0, lower_bound] with
+             lower_bound < 1.0 and with each interval [1e-i, 1e-(i+1)] covered
+             by N values uniformly distributed. For example, lower_bound=1e-2
+             and N=5 returns:
+             [1, 0.8, 0.6, 0.4, 0.2, 0.1, 0.08, 0.06, 0.04, 0.02, 0.01]"""
+            
+            lCMS_values = [1]
+            exp = 0
+            n   = 0
+            while lCMS_values[-1]>=lower_bound:
+                n = (n+1)
+                lCMS_values.append(float('1.0e-%d'%exp)*((N-n%N)/float(N)))
+                if lCMS_values[-1]==lCMS_values[-2]:
+                    lCMS_values.pop()
+                exp = (n+1)//N
+            
+            lCMS_values = lCMS_values[:-1]
+            if lCMS_values[-1]!=lower_bound:
+                lCMS_values.append(lower_bound)
+                
+            return lCMS_values
+        ###### BEGIN do_check
 
         args = self.split_arg(line)
+
         # Check args validity
         param_card = self.check_check(args)
+
         options= {'events':None} # If the momentum needs to be picked from a event file
         if param_card and 'banner' == madevent_interface.MadEventCmd.detect_card_type(param_card):
             logger.info("Will use the param_card contained in the banner and  the events associated")
@@ -3255,31 +3366,280 @@
         if args[0] in ['stability', 'profile']:
             options['npoints'] = int(args[1])
             args = args[:1]+args[2:]
-            
+        
         MLoptions={}
         i=-1
+        CMS_options = {}
         while args[i].startswith('--'):
             option = args[i].split('=')
             if option[0] =='--energy':
                 options['energy']=float(option[1])
             elif option[0]=='--split_orders':
                 options['split_orders']=int(option[1])
+            elif option[0]=='--helicity':
+                try:
+                    options['helicity']=int(option[1])
+                except ValueError:
+                    raise self.InvalidCmd("The value of the 'helicity' option"+\
+                                       " must be an integer, not %s."%option[1])
             elif option[0]=='--reduction':
                 MLoptions['MLReductionLib']=[int(ir) for ir in option[1].split('|')]
+            elif option[0]=='--CTModeRun':
+                try:
+                    MLoptions['CTModeRun']=int(option[1])  
+                except ValueError:
+                    raise self.InvalidCmd("The value of the 'CTModeRun' option"+\
+                                       " must be an integer, not %s."%option[1])
+            elif option[0]=='--offshellness':
+                CMS_options['offshellness'] = float(option[1])
+                if CMS_options['offshellness']<=-1.0:
+                    raise self.InvalidCmd('Offshellness must be number larger or'+
+                           ' equal to -1.0, not %f'%CMS_options['offshellness'])
+            elif option[0]=='--analyze':
+                options['analyze'] = option[1]
+            elif option[0]=='--show_plot':
+                options['show_plot'] = 'true' in option[1].lower()
+            elif option[0]=='--seed':
+                CMS_options['seed'] = int(option[1])
+            elif option[0]=='--name':
+                if '.' in option[1]:
+                    raise self.InvalidCmd("Do not specify the extension in the"+
+                                                             " name of the run")
+                CMS_options['name'] = option[1]
+            elif option[0]=='--resonances':
+                if option[1]=='all':
+                    CMS_options['resonances']  = 'all'
+                else:
+                    try:
+                        resonances=eval(option[1])
+                    except:
+                        raise self.InvalidCmd("Could not evaluate 'resonances'"+
+                                                       " option '%s'"%option[1])
+                    if isinstance(resonances,int) and resonances>0:
+                        CMS_options['resonances']  = resonances
+                    elif isinstance(resonances,list) and all(len(res)==2 and 
+                        isinstance(res[0],int) and all(isinstance(i, int) for i in 
+                                                     res[1]) for res in resonances):
+                        CMS_options['resonances']  = resonances
+                    else:
+                        raise self.InvalidCmd("The option 'resonances' can only be 'all'"+
+                               " or and integer or a list of tuples of the form "+
+                               "(resPDG,(res_mothers_ID)). You gave '%s'"%option[1])
+            elif option[0]=='--tweak':
+                # Lists the sets of custom and widths modifications to apply
+                value = option[1]
+                # Set a shortcuts for applying all relevant tweaks
+                if value=='alltweaks':
+                    value=str(['default','seed667(seed667)','seed668(seed668)',
+                      'allwidths->0.9*allwidths(widths_x_0.9)',
+                      'allwidths->0.99*allwidths(widths_x_0.99)',
+                      'allwidths->1.01*allwidths(widths_x_1.01)',
+                      'allwidths->1.1*allwidths(widths_x_1.1)',                      
+                      'logp->logm(logp2logm)','logm->logp(logm2logp)'])
+                try:
+                    tweaks = eval(value)
+                    if isinstance(tweaks, str):
+                        tweaks = [value]                         
+                    elif not isinstance(tweaks,list):
+                        tweaks = [value]
+                except:
+                    tweaks = [value]
+                if not all(isinstance(t,str) for t in tweaks):
+                    raise self.InvalidCmd("Invalid specificaiton of tweaks: %s"%value)
+                CMS_options['tweak'] = []
+                for tweakID, tweakset in enumerate(tweaks):
+                    specs =re.match(r'^(?P<tweakset>.*)\((?P<name>.*)\)$', tweakset)
+                    if specs:
+                        tweakset = specs.group('tweakset')
+                        name    = specs.group('name')
+                    else:
+                        if tweakset!='default':
+                            name = 'tweak#%d'%(tweakID+1)
+                        else:
+                            name = ''
+                    new_tweak_set = {'custom':[],'params':{},'name':name}
+                    for tweak in tweakset.split('&'):
+                        if tweak=='default':
+                            continue
+                        if tweak.startswith('seed'):
+                            new_tweak_set['custom'].append(tweak)
+                            continue
+                        try:
+                            param, replacement = tweak.split('->')
+                        except ValueError:
+                            raise self.InvalidCmd("Tweak specification '%s'"%\
+                                    tweak+" is incorrect. It should be of"+\
+                                 " the form a->_any_function_of_(a,lambdaCMS).")
+                        if param in ['logp','logm','log'] and \
+                           replacement in ['logp','logm','log']:
+                            new_tweak_set['custom'].append(tweak)
+                            continue
+                        try:
+                            # for safety prefix parameters, because 'as' for alphas
+                            # is a python reserved name for example
+                            orig_param, orig_replacement = param, replacement
+                            replacement = replacement.replace(param,
+                                                        '__tmpprefix__%s'%param)
+                            param = '__tmpprefix__%s'%param
+                            res = float(eval(replacement.lower(),
+                                         {'lambdacms':1.0,param.lower():98.85}))
+                        except:                    
+                            raise self.InvalidCmd("The substitution expression "+
+                        "'%s' for the tweaked parameter"%orig_replacement+
+                        " '%s' could not be evaluated. It must be an "%orig_param+
+                        "expression of the parameter and 'lambdaCMS'.")
+                        new_tweak_set['params'][param.lower()] = replacement.lower()
+                    CMS_options['tweak'].append(new_tweak_set)
+
+            elif option[0]=='--recompute_width':
+                if option[1].lower() not in ['never','always','first_time','auto']:
+                    raise self.InvalidCmd("The option 'recompute_width' can "+\
+                  "only be 'never','always', 'first_time' or 'auto' (default).")
+                CMS_options['recompute_width'] = option[1]
+            elif option[0]=='--loop_filter':
+                # Specify a loop, filter. See functions get_loop_filter and
+                # user_filter in loop_diagram_generation.LoopAmplitude for
+                # information on usage.
+                CMS_options['loop_filter'] = '='.join(option[1:])
+            elif option[0]=='--diff_lambda_power':
+                #'secret' option to chose by which lambda power one should divide
+                # the nwa-cms difference. Useful to set to 2 when doing the Born check
+                # to see whether the NLO check will have sensitivity to the CMS
+                # implementation
+                try:
+                    CMS_options['diff_lambda_power']=float(option[1])
+                except ValueError:
+                    raise self.InvalidCmd("the '--diff_lambda_power' option"+\
+                            " must be an integer or float, not '%s'."%option[1])
+            elif option[0]=='--lambda_plot_range':
+                try:
+                    plot_range=eval(option[1])
+                except Exception as e:
+                    raise self.InvalidCmd("The plot range specified %s"%option[1]+\
+                                   " is not a valid syntax. Error:\n%s"%str(e))
+                if not isinstance(plot_range,(list,tuple)) or \
+                    len(plot_range)!=2 or any(not isinstance(p,(float,int)) 
+                                                           for p in plot_range):                    
+                    raise self.InvalidCmd("The plot range specified %s"\
+                                                       %option[1]+" is invalid")
+                CMS_options['lambda_plot_range']=list([float(p) for p in plot_range])
+            elif option[0]=='--lambdaCMS':
+                try:
+                    lambda_values = eval(option[1])
+                except SyntaxError:
+                    raise self.InvalidCmd("'%s' is not a correct"%option[1]+
+                                     " python expression for lambdaCMS values.")
+                if isinstance(lambda_values,list):
+                    if lambda_values[0]!=1.0:
+                        raise self.InvalidCmd("The first value of the lambdaCMS values"+
+                                " specified must be 1.0, not %s"%str(lambda_values))
+                    for l in lambda_values:
+                        if not isinstance(l,float):
+                            raise self.InvalidCmd("All lambda CMS values must be"+
+                                                          " float, not '%s'"%str(l))
+                elif isinstance(lambda_values,(tuple,float)):
+                    # Format here is then (lower_bound, N) were lower_bound is
+                    # the minimum lambdaCMS value that must be probed and the
+                    # integer N is the number of such values that must be 
+                    # uniformly distributed in each intervale [1.0e-i,1.0e-(i+1)]
+                    if isinstance(lambda_values, float):
+                        # Use default of 10 for the number of lambda values
+                        lower_bound = lambda_values
+                        N = 10
+                    else:
+                        if isinstance(lambda_values[0],float) and \
+                           isinstance(lambda_values[1],int):
+                            lower_bound = lambda_values[0]
+                            N = lambda_values[1]
+                        else:
+                            raise self.InvalidCmd("'%s' must be a "%option[1]+
+                                               "tuple with types (float, int).")
+                    lambda_values = create_lambda_values_list(lower_bound,N)
+                else:
+                    raise self.InvalidCmd("'%s' must be an expression"%option[1]+
+                                          " for either a float, tuple or list.")
+                lower_bound = lambda_values[-1]
+                # and finally add 5 points for stability test on the last values
+                # Depending on how the stab test will behave at NLO, we can 
+                # consider automatically adding the values below
+#                for stab in range(1,6):
+#                    lambda_values.append((1.0+(stab/100.0))*lower_bound)
+
+                CMS_options['lambdaCMS'] = lambda_values
+            elif option[0]=='--cms':
+                try:
+                    CMS_expansion_orders, CMS_expansion_parameters = \
+                                                            option[1].split(',')
+                except ValueError:
+                    raise self.InvalidCmd("CMS expansion specification '%s'"%\
+                                                       args[i]+" is incorrect.")
+                CMS_options['expansion_orders'] = [expansion_order for 
+                             expansion_order in CMS_expansion_orders.split('&')]
+                CMS_options['expansion_parameters'] = {}
+                for expansion_parameter in CMS_expansion_parameters.split('&'):
+                    try:
+                        param, replacement = expansion_parameter.split('->')
+                    except ValueError:
+                        raise self.InvalidCmd("CMS expansion specification '%s'"%\
+                          expansion_parameter+" is incorrect. It should be of"+\
+                                 " the form a->_any_function_of_(a,lambdaCMS).")
+                    try:
+                        # for safety prefix parameters, because 'as' for alphas
+                        # is a python reserved name for example
+                        orig_param, orig_replacement = param, replacement
+                        replacement = replacement.replace(param,
+                                                        '__tmpprefix__%s'%param)
+                        param = '__tmpprefix__%s'%param
+                        res = float(eval(replacement.lower(),
+                                         {'lambdacms':1.0,param.lower():98.85}))
+                    except:                    
+                        raise self.InvalidCmd("The substitution expression "+
+                        "'%s' for CMS expansion parameter"%orig_replacement+
+                        " '%s' could not be evaluated. It must be an "%orig_param+
+                        "expression of the parameter and 'lambdaCMS'.")
+                    # Put everything lower case as it will be done when
+                    # accessing model variables
+                    CMS_options['expansion_parameters'][param.lower()]=\
+                                                             replacement.lower()
+            else:
+                raise self.InvalidCmd("The option '%s' is not reckognized."%option[0])
+
             i=i-1
         args = args[:i+1]
         
+        if args[0]=='options':
+            # Simple printout of the check command options
+            logger.info("Options for the command 'check' are:")
+            logger.info("{:<20}     {}".format('  name','default value'))
+            logger.info("-"*40)
+            for key, value in options.items():
+                logger.info("{:<20} =   {}".format('--%s'%key,str(value)))
+            return
+
+        if args[0].lower()=='cmsoptions':
+            # Simple printout of the special check cms options
+            logger.info("Special options for the command 'check cms' are:")
+            logger.info("{:<20}     {}".format('  name','default value'))
+            logger.info("-"*40)
+            for key, value in CMS_options.items():
+                logger.info("{:<20} =   {}".format('--%s'%key,str(value)))
+            return        
+        
         proc_line = " ".join(args[1:])
-        myprocdef = self.extract_process(proc_line)
+        # Don't try to extract the process if just re-analyzing a saved run
+        if not (args[0]=='cms' and options['analyze']!='None'):
+            myprocdef = self.extract_process(proc_line)
+
+            # Check that we have something
+            if not myprocdef:
+                raise self.InvalidCmd("Empty or wrong format process, please try again.")
+        else:
+            myprocdef = None
 
         # If the test has to write out on disk, it should do so at the location
         # specified below where the user must be sure to have writing access.
         output_path = os.getcwd()
 
-        # Check that we have something
-        if not myprocdef:
-            raise self.InvalidCmd("Empty or wrong format process, please try again.")
-
         if args[0] in ['timing','stability', 'profile'] and not \
                                         myprocdef.get('perturbation_couplings'):
             raise self.InvalidCmd("Only loop processes can have their "+
@@ -3319,8 +3679,9 @@
         # So as a temporary fix for the problem that after doing a check at NLO
         # then a check at LO will fail, I make sure I set it to False if the
         # process is a tree-level one
-        if myprocdef.get('perturbation_couplings')==[]:
-            aloha.loop_mode = False
+        if myprocdef:
+            if myprocdef.get('perturbation_couplings')==[]:
+                aloha.loop_mode = False
 
         comparisons = []
         gauge_result = []
@@ -3331,6 +3692,7 @@
         stability = []
         profile_time = []
         profile_stab = []
+        cms_results = []
 
         if "_cuttools_dir" in dir(self):
             CT_dir = self._cuttools_dir
@@ -3466,15 +3828,88 @@
                                           options=options)
             nb_processes += len(gauge_result)
 
+        # The CMS check is typically more complicated and slower than others
+        # so we don't run it automatically with 'full'.
+        if args[0] in ['cms']:
+            
+            cms_original_setup = self.options['complex_mass_scheme']
+            process_line = " ".join(args[1:])
+            # Merge in the CMS_options to the options
+            for key, value in CMS_options.items():
+                if key=='tweak':
+                    continue
+                if key not in options:
+                    options[key] = value
+                else:
+                    raise MadGraph5Error,"Option '%s' is both in the option"%key+\
+                                                   " and CMS_option dictionary." 
+            
+            if options['analyze']=='None':
+                start = time.time()
+                cms_results = []
+                for tweak in CMS_options['tweak']:
+                    options['tweak']=tweak
+                    # Try to guess the save path and try to load it before running
+                    guessed_proc = myprocdef.get_process(
+                      [leg.get('ids')[0] for leg in myprocdef.get('legs') 
+                                                       if not leg.get('state')],
+                      [leg.get('ids')[0] for leg in myprocdef.get('legs')
+                                                           if leg.get('state')])
+                    save_path = process_checks.CMS_save_path('pkl',
+                    {'ordered_processes':[guessed_proc.base_string()],
+                     'perturbation_orders':guessed_proc.get('perturbation_couplings')}, 
+                             self._curr_model, options, output_path=output_path)
+                    if os.path.isfile(save_path) and options['reuse']:
+                        cms_result = save_load_object.load_from_file(save_path)
+                        logger.info("The cms check for tweak %s is recycled from file:\n %s"%
+                                                      (tweak['name'],save_path))
+                        if cms_result is None:
+                            raise self.InvalidCmd('The complex mass scheme check result'+
+                            " file below could not be read.\n     %s"%save_path)
+                    else:      
+                        cms_result = process_checks.check_complex_mass_scheme(
+                                              process_line,
+                                              param_card = param_card,
+                                              cuttools=CT_dir,
+                                              tir=TIR_dir,
+                                              cmd = self,
+                                              output_path = output_path,
+                                              MLOptions = MLoptions,
+                                              options=options)
+                        # Now set the correct save path
+                        save_path = process_checks.CMS_save_path('pkl', cms_result, 
+                             self._curr_model, options, output_path=output_path)
+                    cms_results.append((cms_result,save_path,tweak['name']))    
+
+                logger.debug('CMS check performed finished in %s.'\
+                                      %misc.format_time(int(time.time()-start)))
+            else:
+                cms_result = save_load_object.load_from_file(
+                                               options['analyze'].split(',')[0])
+                cms_results.append((cms_result,options['analyze'].split(',')[0],
+                                               CMS_options['tweak'][0]['name']))
+                if cms_result is None:
+                    raise self.InvalidCmd('The complex mass scheme check result'+
+                       " file below could not be read.\n     %s"%options['analyze'])
+
+            # restore previous settings
+            self.do_set('complex_mass_scheme %s'%str(cms_original_setup),
+                                                                      log=False)
+            # Use here additional key 'ordered_processes'
+            nb_processes += len(cms_result['ordered_processes'])
+
         cpu_time2 = time.time()
         logger.info("%i checked performed in %0.3f s" \
                     % (nb_processes,
                       (cpu_time2 - cpu_time1)))
 
-        if args[0] not in ['timing','stability', 'profile']:
+        if args[0] in ['cms']:
+                text = "Note that the complex mass scheme test in principle only\n"
+                text+= "works for stable particles in final states.\n\ns"            
+        if args[0] not in ['timing','stability', 'profile', 'cms']:
             if self.options['complex_mass_scheme']:
                 text = "Note that Complex mass scheme gives gauge/lorentz invariant\n"
-                text+= "results only for stable particles in final states.\n\n"
+                text+= "results only for stable particles in final states.\n\ns"
             elif not myprocdef.get('perturbation_couplings'):
                 text = "Note That all width have been set to zero for those checks\n\n"
             else:
@@ -3506,6 +3941,24 @@
         if gauge_result_no_brs:
             text += 'Gauge results (switching between Unitary/Feynman):\n'
             text += process_checks.output_unitary_feynman(gauge_result_no_brs) + '\n'
+        if cms_results:
+            text += 'Complex mass scheme results (varying width in the off-shell regions):\n'
+            cms_result = cms_results[0][0]
+            if len(cms_results)>1:
+                analyze = []
+                for i, (cms_res, save_path, tweakname) in enumerate(cms_results):
+                    save_load_object.save_to_file(save_path, cms_res)
+                    logger.info("Pickle file for tweak '%s' saved to disk at:\n ->%s"%
+                                                          (tweakname,save_path))
+                    if i==0:
+                        analyze.append(save_path)
+                    else:
+                        analyze.append('%s(%s)'%(save_path,tweakname))
+                options['analyze']=','.join(analyze)
+                options['tweak']  = CMS_options['tweak'][0]
+            
+            text += process_checks.output_complex_mass_scheme(
+                    cms_result , output_path, options, self._curr_model) + '\n'
 
         if comparisons and len(comparisons[0])>0:
             text += 'Process permutation results:\n'
@@ -4267,7 +4720,7 @@
                     args[1].split('/')[-1].startswith('loop_qcd_qed_sm')) and\
                      self.options['gauge']!='Feynman':
                     logger.info('Switching to Feynman gauge because '+\
-                          'it is the only one supported by the model loop_qcd_qed_sm.')
+                          'it is the only one supported by the model %s.'%args[1])
                     self._curr_model = None
                     self.do_set('gauge Feynman',log=False)
                 prefix = not '--noprefix' in args
@@ -4277,7 +4730,8 @@
                     aloha.aloha_prefix=''
                 
                 try:
-                    self._curr_model = import_ufo.import_model(args[1], prefix=prefix)
+                    self._curr_model = import_ufo.import_model(args[1], prefix=prefix,
+                        complex_mass_scheme=self.options['complex_mass_scheme'])
                 except import_ufo.UFOImportError, error:
                     if 'not a valid UFO model' in str(error):
                         logger_stderr.warning('WARNING: %s' % error)
@@ -4285,10 +4739,6 @@
                          'automatically `import model_v4 %s` instead.'% args[1])
                     self.exec_cmd('import model_v4 %s ' % args[1], precmd=True)
                     return
-                if self.options['complex_mass_scheme']:
-                    self._curr_model.change_mass_to_complex_scheme()
-                    if hasattr(self._curr_model, 'set_parameters_and_couplings'):
-                        self._curr_model.set_parameters_and_couplings()
                 if self.options['gauge']=='unitary':
                     if not force and isinstance(self._curr_model,\
                                               loop_base_objects.LoopModel) and \
@@ -5614,8 +6064,8 @@
             self.write_configuration(filepath, basefile, basedir, to_define)
 
     # Set an option
-    def do_set(self, line, log=True):
-        """Set an option, which will be default for coming generations/outputs
+    def do_set(self, line, log=True, model_reload=True):
+        """Set an option, which will be default for coming generations/outputs.
         """
 
         # Be careful:
@@ -5673,18 +6123,13 @@
             self.options[args[0]] = eval(args[1])
             aloha.complex_mass = eval(args[1])
             aloha_lib.KERNEL.clean()
-            if not self._curr_model:
-                pass
-            elif self.options[args[0]]:
+            if self.options[args[0]]:
                 if old:
                     if log:
                         logger.info('Complex mass already activated.')
                     return
                 if log:
                     logger.info('Activate complex mass scheme.')
-                self._curr_model.change_mass_to_complex_scheme()
-                if hasattr(self._curr_model, 'set_parameters_and_couplings'):
-                        self._curr_model.set_parameters_and_couplings()
             else:
                 if not old:
                     if log:
@@ -5692,7 +6137,9 @@
                     return
                 if log:
                     logger.info('Desactivate complex mass scheme.')
-                self.exec_cmd('import model %s' % self._curr_model.get('name'))
+            if not self._curr_model:
+                return
+            self.exec_cmd('import model %s' % self._curr_model.get('name'))
 
         elif args[0] == "gauge":
             # Treat the case where they are no model loaded
@@ -6484,8 +6931,7 @@
         else:
             self._curr_model = model
             self._curr_fortran_model = \
-                helas_call_writers.FortranUFOHelasCallWriter(\
-                self._curr_model)
+                  helas_call_writers.FortranUFOHelasCallWriter(self._curr_model)
         if not isinstance(model, model_reader.ModelReader):
             model = model_reader.ModelReader(model)
 
@@ -6857,7 +7303,7 @@
             self._generate_info = process[9:]
             #print self._generate_info
         else:
-            print "No decay is found"
+            logger.info("No decay is found")
 
 class MadGraphCmdWeb(CheckValidForCmdWeb, MadGraphCmd):
     """Temporary parser"""

=== modified file 'madgraph/interface/reweight_interface.py'
--- madgraph/interface/reweight_interface.py	2015-03-25 01:19:54 +0000
+++ madgraph/interface/reweight_interface.py	2015-08-16 06:06:34 +0000
@@ -650,13 +650,11 @@
         model_path = name
 
         # Import model
-        base_model = import_ufo.import_model(name, decay=False)
-
-
+        base_model = import_ufo.import_model(name, decay=False,
+                                               complex_mass_scheme=complex_mass)
+    
         if use_mg_default:
             base_model.pass_particles_name_in_mg_default()
-        if complex_mass:
-            base_model.change_mass_to_complex_scheme()
         
         self.model = base_model
         self.mg5cmd._curr_model = self.model

=== modified file 'madgraph/iolibs/export_v4.py'
--- madgraph/iolibs/export_v4.py	2015-08-05 17:00:28 +0000
+++ madgraph/iolibs/export_v4.py	2015-08-16 06:06:34 +0000
@@ -5536,11 +5536,11 @@
         # in Gmu scheme, aEWM1 is not external but Gf is an exteranl variable
         elif ('Gf',) in self.model['parameters']:
             if dp:
-                fsock.writelines(""" gal(1) = 2.378414230005442133435d0*MDL_MW*MDL_SW*DSQRT(MDL_Gf)
+                fsock.writelines(""" gal(1) = 2.378414230005442133435d0*MDL_MW*DSQRT(1D0-MDL_MW**2/MDL_MZ**2)*DSQRT(MDL_Gf)
                                  gal(2) = 1d0
                          """)
             elif mp:
-                fsock.writelines(""" %(mp_prefix)sgal(1) = 2*MP__MDL_MW*MP__MDL_SW*SQRT(SQRT(2e0_16)*MP__MDL_Gf)
+                fsock.writelines(""" %(mp_prefix)sgal(1) = 2*MP__MDL_MW*SQRT(1e0_16-MP__MDL_MW**2/MP__MDL_MZ**2)*SQRT(SQRT(2e0_16)*MP__MDL_Gf)
                                  %(mp_prefix)sgal(2) = 1d0
                                  """ %{'mp_prefix':self.mp_prefix})
                 pass
@@ -5747,11 +5747,17 @@
         fsock.writelines("""double complex cond
           double complex condif
           double complex reglog
+          double complex reglogp
+          double complex reglogm
+          double complex recms
           double complex arg""")
         if self.opt['mp']:
             fsock.writelines("""%(complex_mp_format)s mp_cond
           %(complex_mp_format)s mp_condif
           %(complex_mp_format)s mp_reglog
+          %(complex_mp_format)s mp_reglogp
+          %(complex_mp_format)s mp_reglogm
+          %(complex_mp_format)s mp_recms
           %(complex_mp_format)s mp_arg"""\
           %{'complex_mp_format':self.mp_complex_format})
 
@@ -5782,9 +5788,22 @@
              condif=falsecase
           endif
           end
+
+          double complex function recms(condition,expr)
+          implicit none
+          logical condition
+          double complex expr
+          if(condition)then
+             recms=expr
+          else
+             recms=dcmplx(dble(expr))
+          endif
+          end
           
           double complex function reglog(arg)
           implicit none
+          double complex TWOPII
+          parameter (TWOPII=2.0d0*3.1415926535897932d0*(0.0d0,1.0d0))
           double complex arg
           if(arg.eq.(0.0d0,0.0d0)) then
              reglog=(0.0d0,0.0d0)
@@ -5795,12 +5814,14 @@
 
           double complex function reglogp(arg)
           implicit none
+          double complex TWOPII
+          parameter (TWOPII=2.0d0*3.1415926535897932d0*(0.0d0,1.0d0))
           double complex arg
           if(arg.eq.(0.0d0,0.0d0))then
              reglogp=(0.0d0,0.0d0)
           else
              if(dble(arg).lt.0.0d0.and.dimag(arg).lt.0.0d0)then
-                reglogp=log(arg) + 2.0d0*3.1415926535897932d0*(0.0d0,1.0d0)
+                reglogp=log(arg) + TWOPII
              else
                 reglogp=log(arg)
              endif
@@ -5809,18 +5830,20 @@
 
           double complex function reglogm(arg)
           implicit none
+          double complex TWOPII
+          parameter (TWOPII=2.0d0*3.1415926535897932d0*(0.0d0,1.0d0))
           double complex arg
           if(arg.eq.(0.0d0,0.0d0))then
              reglogm=(0.0d0,0.0d0)
           else
              if(dble(arg).lt.0.0d0.and.dimag(arg).gt.0.0d0)then
-                reglogm=log(arg) - 2.0d0*3.1415926535897932d0*(0.0d0,1.0d0)
+                reglogm=log(arg) - TWOPII
              else
                 reglogm=log(arg)
              endif
           endif
           end
-
+          
           double complex function arg(comnum)
           implicit none
           double complex comnum
@@ -5855,9 +5878,22 @@
                  mp_condif=falsecase
               endif
               end
+
+              %(complex_mp_format)s function mp_recms(condition,expr)
+              implicit none
+              logical condition
+              %(complex_mp_format)s expr
+              if(condition)then
+                 mp_recms=expr
+              else
+                 mp_recms=cmplx(real(expr),kind=16)
+              endif
+              end
               
               %(complex_mp_format)s function mp_reglog(arg)
               implicit none
+              %(complex_mp_format)s TWOPII
+              parameter (TWOPII=2.0e0_16*3.14169258478796109557151794433593750e0_16*(0.0e0_16,1.0e0_16))
               %(complex_mp_format)s arg
               if(arg.eq.(0.0e0_16,0.0e0_16)) then
                  mp_reglog=(0.0e0_16,0.0e0_16)
@@ -5868,26 +5904,30 @@
 
               %(complex_mp_format)s function mp_reglogp(arg)
               implicit none
+              %(complex_mp_format)s TWOPII
+              parameter (TWOPII=2.0e0_16*3.14169258478796109557151794433593750e0_16*(0.0e0_16,1.0e0_16))
               %(complex_mp_format)s arg
               if(arg.eq.(0.0e0_16,0.0e0_16))then
                  mp_reglogp=(0.0e0_16,0.0e0_16)
               else
                  if(real(arg,kind=16).lt.0.0e0_16.and.imagpart(arg).lt.0.0e0_16)then
-                    mp_reglogp=log(arg) + 2.0e0_16*3.14169258478796109557151794433593750e0_16*(0.0e0_16,1.0e0_16)
+                    mp_reglogp=log(arg) + TWOPII
                  else
                     mp_reglogp=log(arg)
                  endif
               endif
               end
- 
+              
               %(complex_mp_format)s function mp_reglogm(arg)
               implicit none
+              %(complex_mp_format)s TWOPII
+              parameter (TWOPII=2.0e0_16*3.14169258478796109557151794433593750e0_16*(0.0e0_16,1.0e0_16))
               %(complex_mp_format)s arg
               if(arg.eq.(0.0e0_16,0.0e0_16))then
                  mp_reglogm=(0.0e0_16,0.0e0_16)
               else
                  if(real(arg,kind=16).lt.0.0e0_16.and.imagpart(arg).gt.0.0e0_16)then
-                    mp_reglogm=log(arg) - 2.0e0_16*3.14169258478796109557151794433593750e0_16*(0.0e0_16,1.0e0_16)
+                    mp_reglogm=log(arg) - TWOPII
                  else
                     mp_reglogm=log(arg)
                  endif 
@@ -5921,9 +5961,8 @@
             fsock.write_comment_line(' START UFO DEFINE FUNCTIONS ')
             for fct in ufo_fct:
                 # already handle by default
-                if fct.name not in ["complexconjugate", "re", "im", "sec", 
-                  "csc", "asec", "acsc", "theta_function", "cond", 
-                  "condif", "reglogp", "reglogm", "reglog", "arg"]:
+                if fct.name not in ["complexconjugate", "re", "im", "sec", "csc", "asec", "acsc", "condif",
+                                    "theta_function", "cond", "reglog", "reglogp", "reglogm", "recms","arg"]:
                     ufo_fct_template = """
           double complex function %(name)s(%(args)s)
           implicit none
@@ -5943,9 +5982,8 @@
                 fsock.write_comment_line(' START UFO DEFINE FUNCTIONS FOR MP')
                 for fct in ufo_fct:
                     # already handle by default
-                    if fct.name not in ["complexconjugate", "re", "im", "sec",
-                      "csc", "asec", "acsc", "theta_function", "cond", 
-                      "condif", "reglogp", "reglogm", "reglog", "arg"]:
+                    if fct.name not in ["complexconjugate", "re", "im", "sec", "csc", "asec", "acsc","condif",
+                                        "theta_function", "cond", "reglog", "reglogp","reglogm", "recms","arg"]:
                         ufo_fct_template = """
           %(complex_mp_format)s function mp__%(name)s(mp__%(args)s)
           implicit none

=== modified file 'madgraph/iolibs/template_files/loop/check_sa.inc'
--- madgraph/iolibs/template_files/loop/check_sa.inc	2015-06-18 08:24:43 +0000
+++ madgraph/iolibs/template_files/loop/check_sa.inc	2015-08-16 06:06:34 +0000
@@ -305,6 +305,7 @@
         write (69,'(a4,1x,1e25.15)') '1EPS',MATELEM(2,0)/AO2PI
         write (69,'(a4,1x,1e25.15)') '2EPS',MATELEM(3,0)/AO2PI
 	  ENDIF
+      write (69,'(a6,1x,1e25.15)') 'ASO2PI',AO2PI
       write (69,*) 'Export_Format Default'
 	  write (69,'(a7,1x,i3)') 'RETCODE',RETURNCODE
 	  write (69,'(a3,1x,1e10.4)') 'ACC',PREC_FOUND(0)

=== modified file 'madgraph/iolibs/template_files/loop/check_sa_loop_induced.inc'
--- madgraph/iolibs/template_files/loop/check_sa_loop_induced.inc	2015-06-18 08:24:43 +0000
+++ madgraph/iolibs/template_files/loop/check_sa_loop_induced.inc	2015-08-16 06:06:34 +0000
@@ -265,6 +265,7 @@
       write (69,'(a3,1x,1e25.15)') 'FIN',MATELEM(1,0)
       write (69,'(a4,1x,1e25.15)') '1EPS',MATELEM(2,0)
       write (69,'(a4,1x,1e25.15)') '2EPS',MATELEM(3,0)
+      write (69,'(a6,1x,1e25.15)') 'ASO2PI',AO2PI
       write (69,*) 'Export_Format LoopInduced'
 	  write (69,'(a7,1x,i3)') 'RETCODE',RETURNCODE
 	  write (69,'(a3,1x,1e10.4)') 'ACC',PREC_FOUND(0)

=== modified file 'madgraph/iolibs/ufo_expression_parsers.py'
--- madgraph/iolibs/ufo_expression_parsers.py	2015-08-04 14:28:22 +0000
+++ madgraph/iolibs/ufo_expression_parsers.py	2015-08-16 06:06:34 +0000
@@ -65,7 +65,7 @@
     tokens = (
         'LOGICAL','LOGICALCOMB','POWER', 'CSC', 'SEC', 'ACSC', 'ASEC', 'TAN',
         'SQRT', 'CONJ', 'RE', 'RE2', 'IM', 'PI', 'COMPLEX', 'FUNCTION', 'IF','ELSE',
-        'VARIABLE', 'NUMBER','COND','REGLOG', 'ARG'
+        'VARIABLE', 'NUMBER','COND','REGLOG', 'REGLOGP', 'REGLOGM','RECMS','ARG'
         )
     literals = "=+-*/(),"
 
@@ -89,6 +89,15 @@
     def t_REGLOG(self, t):
         r'(?<!\w)reglog(?=\()'
         return t
+    def t_REGLOGP(self, t):
+        r'(?<!\w)reglogp(?=\()'
+        return t
+    def t_REGLOGM(self, t):
+        r'(?<!\w)reglogm(?=\()'
+        return t
+    def t_RECMS(self, t):
+        r'(?<!\w)recms(?=\()'
+        return t
     def t_COND(self, t):
         r'(?<!\w)cond(?=\()'
         return t
@@ -169,6 +178,9 @@
         ('right','UMINUS'),
         ('left','POWER'),
         ('right','REGLOG'),
+        ('right','REGLOGP'),
+        ('right','REGLOGM'),
+        ('right','RECMS'),
         ('right','ARG'),
         ('right','CSC'),
         ('right','SEC'),
@@ -302,6 +314,10 @@
         "expression :  COND '(' expression ',' expression ',' expression ')'"
         p[0] = 'COND(DCMPLX('+p[3]+'),DCMPLX('+p[5]+'),DCMPLX('+p[7]+'))'
 
+    def p_expression_recms(self, p):
+        "expression : RECMS '(' boolexpression ',' expression ')'"
+        p[0] = 'RECMS('+p[3]+',DCMPLX('+p[5]+'))'
+
     def p_expression_complex(self, p):
         "expression : COMPLEX '(' expression ',' expression ')'"
         p[0] = 'DCMPLX(' + p[3] + ',' + p[5] + ')'
@@ -313,10 +329,12 @@
                       | ASEC group
                       | RE group
                       | IM group
-		              | ARG group
+                      | ARG group
                       | SQRT group
                       | CONJ group
                       | REGLOG group
+                      | REGLOGP group
+                      | REGLOGM group
                       | TAN group'''
 
         if p[1] == 'csc': p[0] = '1d0/cos' + p[2]
@@ -330,6 +348,8 @@
         elif p[1] == 'cmath.sqrt' or p[1] == 'sqrt': p[0] = 'sqrt(dcmplx' + p[2]+')'
         elif p[1] == 'complexconjugate': p[0] = 'conjg(DCMPLX' + p[2]+')'
         elif p[1] == 'reglog': p[0] = 'reglog(DCMPLX' + p[2] +')'
+        elif p[1] == 'reglogp': p[0] = 'reglogp(DCMPLX' + p[2] + ')'
+        elif p[1] == 'reglogm': p[0] = 'reglogm(DCMPLX' + p[2] + ')'
 
 
     def p_expression_real(self, p):
@@ -403,6 +423,10 @@
         p[0] = 'MP_COND(CMPLX('+p[3]+',KIND=16),CMPLX('+p[5]+\
                                           ',KIND=16),CMPLX('+p[7]+',KIND=16))'
 
+    def p_expression_recms(self, p):
+        "expression : RECMS '(' boolexpression ',' expression ')'"
+        p[0] = 'MP_RECMS('+p[3]+',CMPLX('+p[5]+',KIND=16))'
+
     def p_expression_func(self, p):
         '''expression : CSC group
                       | SEC group
@@ -410,11 +434,14 @@
                       | ASEC group
                       | RE group
                       | IM group
-	                  | ARG group
+                      | ARG group
                       | SQRT group
                       | CONJ group
-                      | TAN group
-                      | REGLOG group'''
+                      | REGLOG group
+                      | REGLOGP group
+                      | REGLOGM group
+                      | TAN group'''
+        
         if p[1] == 'csc': p[0] = '1e0_16/cos' + p[2]
         elif p[1] == 'sec': p[0] = '1e0_16/sin' + p[2]
         elif p[1] == 'acsc': p[0] = 'asin(1e0_16/' + p[2] + ')'
@@ -426,6 +453,8 @@
         elif p[1] == 'cmath.sqrt' or p[1] == 'sqrt': p[0] = 'sqrt(CMPLX(' + p[2] + ',KIND=16))'
         elif p[1] == 'complexconjugate': p[0] = 'conjg(CMPLX(' + p[2] + ',KIND=16))'
         elif p[1] == 'reglog': p[0] = 'mp_reglog(CMPLX(' + p[2] +',KIND=16))'
+        elif p[1] == 'reglogp': p[0] = 'mp_reglogp(CMPLX(' + p[2] + ',KIND=16))'
+        elif p[1] == 'reglogm': p[0] = 'mp_reglogm(CMPLX(' + p[2] + ',KIND=16))'
 
     def p_expression_real(self, p):
         ''' expression : expression RE2 '''
@@ -492,6 +521,10 @@
         "expression :  COND '(' expression ',' expression ',' expression ')'"
         p[0] = 'COND('+p[3]+','+p[5]+','+p[7]+')'
 
+    def p_expression_recms(self, p):
+        "expression : RECMS '(' boolexpression ',' expression ')'"
+        p[0] = 'RECMS('+p[3]+','+p[5]+')'
+
     def p_expression_power(self, p):
         'expression : expression POWER expression'
         p1=p[1]
@@ -514,10 +547,12 @@
                       | TAN group
                       | RE group
                       | IM group
-		              | ARG group
+                      | ARG group
                       | SQRT group
                       | CONJ group
-                      | REGLOG group '''
+                      | REGLOG group 
+                      | REGLOGP group
+                      | REGLOGM group'''
         if p[1] == 'csc': p[0] = '1./cos' + p[2]
         elif p[1] == 'sec': p[0] = '1./sin' + p[2]
         elif p[1] == 'acsc': p[0] = 'asin(1./' + p[2] + ')'
@@ -529,6 +564,8 @@
         elif p[1] == 'cmath.sqrt' or p[1] == 'sqrt': p[0] = 'sqrt' + p[2]
         elif p[1] == 'complexconjugate': p[0] = 'conj' + p[2]
         elif p[1] == 'reglog': p[0] = 'reglog' + p[2]
+        elif p[1] == 'reglogp': p[0] = 'reglogp' + p[2]
+        elif p[1] == 'reglogm': p[0] = 'reglogm' + p[2]
 
     def p_expression_real(self, p):
         ''' expression : expression RE2 '''
@@ -652,6 +689,10 @@
         "expression : COMPLEX '(' expression ',' expression ')'"
         p[0] = 'complex(' + p[3] + ',' + p[5] + ')'
 
+    def p_expression_recms(self, p):
+        "expression : RECMS '(' boolexpression ',' expression ')'"
+        p[0] = 'recms('+p[3]+','+p[5]+')'
+
     def p_expression_func(self, p):
         '''expression : CSC group
                       | SEC group
@@ -663,7 +704,9 @@
                       | SQRT group
                       | TAN group
                       | CONJ group
-                      | REGLOG group'''
+                      | REGLOG group
+                      | REGLOGP group
+                      | REGLOGM group'''
         if p[1] == 'csc': p[0] = 'csc' + p[2]
         elif p[1] == 'sec': p[0] = 'sec' + p[2]
         elif p[1] == 'acsc': p[0] = 'acsc' + p[2]
@@ -675,6 +718,8 @@
         elif p[1] == 'cmath.sqrt' or p[1] == 'sqrt': p[0] = 'cmath.sqrt' + p[2]
         elif p[1] == 'complexconjugate': p[0] = 'complexconjugate' + p[2]
         elif p[1] == 'reglog': p[0] = 'reglog' + p[2]
+        elif p[1] == 'reglogp': p[0] = 'reglogp' + p[2]
+        elif p[1] == 'reglogm': p[0] = 'reglogm' + p[2]
 
     def p_expression_real(self, p):
         ''' expression : expression RE2 '''

=== modified file 'madgraph/loop/loop_diagram_generation.py'
--- madgraph/loop/loop_diagram_generation.py	2015-04-03 01:23:08 +0000
+++ madgraph/loop/loop_diagram_generation.py	2015-08-16 06:06:34 +0000
@@ -74,13 +74,13 @@
         # subsequent diagram generation runs.
         self.lcutpartemployed=[]
 
-    def __init__(self, argument=None):
+    def __init__(self, argument=None, loop_filter=None):
         """Allow initialization with Process"""
         
         if isinstance(argument, base_objects.Process):
             super(LoopAmplitude, self).__init__()
             self.set('process', argument)
-            self.generate_diagrams()
+            self.generate_diagrams(loop_filter=loop_filter)
         elif argument != None:
             # call the mother routine
             super(LoopAmplitude, self).__init__(argument)
@@ -345,17 +345,49 @@
             logger.debug(("MadLoop discarded %i diagram%s because they appeared"+\
               " to be zero because of Furry theorem.")%(n_discarded,'' if \
                                                        n_discarded<=1 else 's'))
-        
-    def user_filter(self, model, structs):
+    
+    @staticmethod   
+    def get_loop_filter(filterdef):
+        """ Returns a function which applies the filter corresponding to the 
+        conditional expression encoded in filterdef."""
+        
+        def filter(diag, structs, model, id):
+            """ The filter function generated '%s'."""%filterdef
+            
+            loop_pdgs   = diag.get_loop_lines_pdgs()
+            struct_pdgs = diag.get_pdgs_attached_to_loop(structs)
+            loop_masses = [model.get_particle(pdg).get('mass') for pdg in loop_pdgs]
+            struct_masses = [model.get_particle(pdg).get('mass') for pdg in struct_pdgs]
+            if not eval(filterdef.lower(),{'n':len(loop_pdgs),
+                                        'loop_pdgs':loop_pdgs,
+                                        'struct_pdgs':struct_pdgs,
+                                        'loop_masses':loop_masses,
+                                        'struct_masses':struct_masses,
+                                        'id':id}):
+                return False
+            else:
+                return True
+        
+        return filter
+        
+    def user_filter(self, model, structs, filter=None):
         """ User-defined user-filter. By default it is not called, but the expert
         user can turn it on and code here is own filter. Some default examples
         are provided here.
         The tagging of the loop diagrams must be performed before using this 
         user loop filter"""
         
-        # By default the user filter does nothing, if you want to turn it on
-        # and edit it then remove the print statement below.
-        return
+        # By default the user filter does nothing if filter is not set, 
+        # if you want to turn it on and edit it by hand, then set the 
+        # variable edit_filter_manually to True
+        edit_filter_manually = False
+        if not edit_filter_manually and filter in [None,'None']:
+            return
+
+        if filter not in [None,'None']:
+            filter_func = LoopAmplitude.get_loop_filter(filter)
+        else:
+            filter_func = None
 
         new_diag_selection = base_objects.DiagramList()
         discarded_diags = base_objects.DiagramList()
@@ -366,6 +398,14 @@
                        "make sure that the loop diagrams have been tagged first."
             valid_diag = True
             i=i+1
+    
+            # Apply the custom filter specified if any
+            if filter_func:
+                try:
+                    valid_diag = filter_func(diag, structs, model, i)
+                except Exception as e:
+                    raise InvalidCmd("The user-defined filter '%s' did not"%filter+
+                                 " returned the following error:\n       > %s"%str(e))
 #            if any([abs(i)!=1000021 for i in diag.get_loop_lines_pdgs()]):
 #                valid_diag=False
             
@@ -427,9 +467,14 @@
                 discarded_diags.append(diag)
                 
         self['loop_diagrams'] = new_diag_selection
-        warn_msg = """
+        if filter in [None,'None']:
+            warn_msg = """
     The user-defined loop diagrams filter is turned on and discarded %d loops."""\
     %len(discarded_diags)
+        else:
+            warn_msg = """
+    The loop diagrams filter '%s' is turned on and discarded %d loops."""\
+                                                  %(filter,len(discarded_diags))
         logger.warning(warn_msg)
 
     def filter_loop_for_perturbative_orders(self):
@@ -531,7 +576,7 @@
                 res.append('%s=*'%order)
         return ','.join(res)
 
-    def generate_diagrams(self):
+    def generate_diagrams(self, loop_filter=None):
         """ Generates all diagrams relevant to this Loop Process """
 
         # Description of the algorithm to guess the leading contribution.
@@ -808,7 +853,7 @@
         # For expert only, you can edit your own filter by modifying the
         # user_filter() function which by default does nothing but in which you
         # will find examples of common filters.
-        self.user_filter(model,self['structure_repository'])
+        self.user_filter(model,self['structure_repository'], filter=loop_filter)
 
         # Now revert the squared order. This function typically adds to the 
         # squared order list the target WEIGHTED order which has been detected.

=== modified file 'madgraph/various/lhe_parser.py'
--- madgraph/various/lhe_parser.py	2015-08-03 16:13:26 +0000
+++ madgraph/various/lhe_parser.py	2015-08-16 06:06:34 +0000
@@ -219,8 +219,7 @@
         self.len = nb_event
         self.seek(init_pos)
         return self.len
-        
-    
+
     def next(self):
         """get next event"""
         text = ''

=== modified file 'madgraph/various/process_checks.py'
--- madgraph/various/process_checks.py	2015-05-08 23:38:18 +0000
+++ madgraph/various/process_checks.py	2015-08-16 06:06:34 +0000
@@ -36,6 +36,7 @@
 import time
 import datetime
 import errno
+import pickle
 # If psutil becomes standard, the RAM check can be performed with it instead
 #import psutil
 
@@ -47,6 +48,7 @@
 import madgraph.iolibs.helas_call_writers as helas_call_writers
 import models.import_ufo as import_ufo
 import madgraph.iolibs.save_load_object as save_load_object
+import madgraph.iolibs.file_writers as writers
 
 import madgraph.core.base_objects as base_objects
 import madgraph.core.color_algebra as color
@@ -58,17 +60,20 @@
 import madgraph.various.misc as misc
 import madgraph.various.progressbar as pbar
 import madgraph.various.banner as bannermod
+import madgraph.various.progressbar as pbar
 
 import madgraph.loop.loop_diagram_generation as loop_diagram_generation
 import madgraph.loop.loop_helas_objects as loop_helas_objects
 import madgraph.loop.loop_base_objects as loop_base_objects
+import models.check_param_card as check_param_card
 
 from madgraph.interface.madevent_interface import MadLoopInitializer
-
+from madgraph.interface.common_run_interface import AskforEditCard
 from madgraph import MG5DIR, InvalidCmd, MadGraph5Error
 
 from madgraph.iolibs.files import cp
 
+import StringIO
 import models.model_reader as model_reader
 import aloha.template_files.wavefunctions as wavefunctions
 from aloha.template_files.wavefunctions import \
@@ -170,7 +175,8 @@
         except MadGraph5Error:
             if isinstance(param_card, (str,file)):
                 raise
-            logger.warning('param_card present in the event file not compatible. We will use the default one.')
+            logger.warning('param_card present in the event file not compatible.'+
+                                                ' We will use the default one.')
             self.full_model.set_parameters_and_couplings()
             
         self.auth_skipping = auth_skipping
@@ -288,11 +294,10 @@
         # Export the matrix element to Python calls
         exporter = export_python.ProcessExporterPython(matrix_element,
                                                        self.helas_writer)
-
         try:
             matrix_methods = exporter.get_python_matrix_methods(\
                 gauge_check=gauge_check)
-            # print "I got matrix_methods=",str(matrix_methods.items()[0][1])
+#            print "I got matrix_methods=",str(matrix_methods.items()[0][1])
         except helas_call_writers.HelasWriterError, error:
             logger.info(error)
             return None
@@ -317,14 +322,52 @@
             m2 = data.smatrix(p,self.full_model)
             return {'m2': m2, output:getattr(data, output)}
     
+    @staticmethod
+    def pass_isolation_cuts(pmoms, ptcut=50.0, drcut=0.5):
+        """ Check whether the specified kinematic point passes isolation cuts
+        """
+
+        def Pt(pmom):
+            """ Computes the pt of a 4-momentum"""
+            return math.sqrt(pmom[1]**2+pmom[2]**2)
+
+        def DeltaR(p1,p2):
+            """ Computes the DeltaR between two 4-momenta"""
+            # First compute pseudo-rapidities
+            p1_vec=math.sqrt(p1[1]**2+p1[2]**2+p1[3]**2)
+            p2_vec=math.sqrt(p2[1]**2+p2[2]**2+p2[3]**2)    
+            eta1=0.5*math.log((p1_vec+p1[3])/(p1_vec-p1[3]))
+            eta2=0.5*math.log((p2_vec+p2[3])/(p2_vec-p2[3]))
+            # Then azimutal angle phi
+            phi1=math.atan2(p1[2],p1[1])
+            phi2=math.atan2(p2[2],p2[1])
+            dphi=abs(phi2-phi1)
+            # Take the wraparound factor into account
+            dphi=abs(abs(dphi-math.pi)-math.pi)
+            # Now return deltaR
+            return math.sqrt(dphi**2+(eta2-eta1)**2)
+
+        for i, pmom in enumerate(pmoms[2:]):
+            # Pt > 50 GeV
+            if Pt(pmom)<ptcut:
+                return False
+            # Delta_R ij > 0.5
+            for pmom2 in pmoms[3+i:]:
+                if DeltaR(pmom,pmom2)<drcut:
+                    return False
+        return True
+    
     #===============================================================================
     # Helper function get_momenta
     #===============================================================================
-    def get_momenta(self, process, options=None):
+    def get_momenta(self, process, options=None, special_mass=None):
         """Get a point in phase space for the external states in the given
         process, with the CM energy given. The incoming particles are
         assumed to be oriented along the z axis, with particle 1 along the
-        positive z axis."""
+        positive z axis.
+        For the CMS check, one must be able to chose the mass of the special
+        resonance particle with id = -1, and the special_mass option allows
+        to specify it."""
 
         if not options:
             energy=1000
@@ -340,7 +383,7 @@
 
 
         sorted_legs = sorted(process.get('legs'), lambda l1, l2:\
-                             l1.get('number') - l2.get('number'))
+                                            l1.get('number') - l2.get('number'))
 
         # If an events file is given use it for getting the momentum
         if events:
@@ -371,17 +414,33 @@
         nfinal = len(sorted_legs) - nincoming
 
         # Find masses of particles
-        mass_strings = [self.full_model.get_particle(l.get('id')).get('mass') \
-                         for l in sorted_legs]        
-        mass = [self.full_model.get('parameter_dict')[m] for m in mass_strings]
-        mass = [m.real for m in mass]
+        mass = []
+        for l in sorted_legs:
+            if l.get('id') != 0:
+                mass_string = self.full_model.get_particle(l.get('id')).get('mass')        
+                mass.append(self.full_model.get('parameter_dict')[mass_string].real)
+            else:
+                if isinstance(special_mass, float):
+                    mass.append(special_mass)
+                else:
+                    raise Exception, "A 'special_mass' option must be specified"+\
+                 " in get_momenta when a leg with id=-10 is present (for CMS check)"
         #mass = [math.sqrt(m.real) for m in mass]
 
 
 
-        # Make sure energy is large enough for incoming and outgoing particles
-        energy = max(energy, sum(mass[:nincoming]) + 200.,
-                     sum(mass[nincoming:]) + 200.)
+        # Make sure energy is large enough for incoming and outgoing particles,
+#        # Keep the special_mass case separate to be sure that nothing interferes
+#        # with the regular usage of get_momenta.
+#        if not (any(l.get('id')==0 for l in sorted_legs) and \
+#                                               isinstance(special_mass, float)):
+        energy = max(energy, sum(mass[:nincoming])*1.2,sum(mass[nincoming:])*1.2)
+#        else:
+#            incoming_mass = sum([mass[i] for i, leg in enumerate(sorted_legs) \
+#                             if leg.get('state') == False and leg.get('id')!=0])
+#            outcoming_mass = sum([mass[i] for i, leg in enumerate(sorted_legs) \
+#                             if leg.get('state') == True and leg.get('id')!=0])
+#            energy = max(energy, incoming_mass*1.2, outcoming_mass*1.2)
 
         if nfinal == 1:
             p = []
@@ -400,12 +459,9 @@
             masses[i+1] = mass[nincoming + i]
 
         if nincoming == 1:
-
             # Momenta for the incoming particle
             p.append([abs(m1), 0., 0., 0.])
-
             p_rambo, w_rambo = rambo.RAMBO(nfinal, abs(m1), masses)
-
             # Reorder momenta from px,py,pz,E to E,px,py,pz scheme
             for i in range(1, nfinal+1):
                 momi = [p_rambo[(4,i)], p_rambo[(1,i)],
@@ -451,6 +507,7 @@
 #===============================================================================
 # Helper class LoopMatrixElementEvaluator
 #===============================================================================
+
 class LoopMatrixElementEvaluator(MatrixElementEvaluator):
     """Class taking care of matrix element evaluation for loop processes."""
 
@@ -652,16 +709,16 @@
                 raise Exception, 'The MadLoop options %s specified in function'%key+\
                   ' fix_MadLoopParamCard does not correspond to an option defined'+\
                   ' MadLoop nor is it specially handled in this function.'
-
-        MLCard.set('CTModeRun',mode)
-        MLCard.set('CTModeInit',mode)
+        if not mode is None:
+            MLCard.set('CTModeRun',mode)
+            MLCard.set('CTModeInit',mode)
         MLCard.set('UseLoopFilter',loop_filter)
         MLCard.set('DoubleCheckHelicityFilter',DoubleCheckHelicityFilter)
         MLCard.write(pjoin(dir_name,os.pardir,'SubProcesses','MadLoopParams.dat'))
 
     @classmethod
-    def get_me_value(cls, proc, proc_id, working_dir, PSpoint=[], \
-                                                  PS_name = None, verbose=True):
+    def get_me_value(cls, proc, proc_id, working_dir, PSpoint=[], PS_name = None,
+                          verbose=True, format='tuple', skip_compilation=False):
         """Compile and run ./check, then parse the output and return the result
         for process with id = proc_id and PSpoint if specified.
         If PS_name is not none the written out PS.input will be saved in 
@@ -684,23 +741,24 @@
         if verbose: logging.debug("Working on process %s in dir %s" % (proc, shell_name))
         
         dir_name = pjoin(working_dir, 'SubProcesses', shell_name)
-        # Make sure to recreate the executable and modified sources
-        if os.path.isfile(pjoin(dir_name,'check')):
-            os.remove(pjoin(dir_name,'check'))
-            try:
-                os.remove(pjoin(dir_name,'check_sa.o'))
-                os.remove(pjoin(dir_name,'loop_matrix.o'))
-            except OSError:
-                pass
-        # Now run make
-        devnull = open(os.devnull, 'w')
-        retcode = subprocess.call(['make','check'],
-                                   cwd=dir_name, stdout=devnull, stderr=devnull)
-        devnull.close()
-                     
-        if retcode != 0:
-            logging.info("Error while executing make in %s" % shell_name)
-            return ((0.0, 0.0, 0.0, 0.0, 0), [])
+        if not skip_compilation:
+            # Make sure to recreate the executable and modified sources
+            if os.path.isfile(pjoin(dir_name,'check')):
+                os.remove(pjoin(dir_name,'check'))
+                try:
+                    os.remove(pjoin(dir_name,'check_sa.o'))
+                    os.remove(pjoin(dir_name,'loop_matrix.o'))
+                except OSError:
+                    pass
+            # Now run make
+            devnull = open(os.devnull, 'w')
+            retcode = subprocess.call(['make','check'],
+                                       cwd=dir_name, stdout=devnull, stderr=devnull)
+            devnull.close()
+                         
+            if retcode != 0:
+                logging.info("Error while executing make in %s" % shell_name)
+                return ((0.0, 0.0, 0.0, 0.0, 0), [])
 
         # If a PS point is specified, write out the corresponding PS.input
         if PSpoint:
@@ -719,7 +777,7 @@
             output.close()
             if os.path.exists(pjoin(dir_name,'result.dat')):
                 return cls.parse_check_output(file(pjoin(dir_name,\
-                                                  'result.dat')),format='tuple')  
+                                                   'result.dat')),format=format)  
             else:
                 logging.warning("Error while looking for file %s"%str(os.path\
                                            .join(dir_name,'result.dat')))
@@ -767,6 +825,8 @@
                 continue
             elif splitline[0]=='PS':
                 res_p.append([float(s) for s in splitline[1:]])
+            elif splitline[0]=='ASO2PI':
+                res_dict['alphaS_over_2pi']=float(splitline[1])
             elif splitline[0]=='BORN':
                 res_dict['born']=float(splitline[1])
             elif splitline[0]=='FIN':
@@ -809,6 +869,122 @@
         else:
             return res_dict
     
+    @staticmethod
+    def apply_log_tweak(proc_path, mode):
+        """ Changes the file model_functions.f in the SOURCE of the process output
+        so as to change how logarithms are analytically continued and see how
+        it impacts the CMS check."""
+        valid_modes = ['default','recompile']
+        if not (mode in valid_modes or (isinstance(mode, list) and
+                len(mode)==2 and all(m in ['logp','logm','log'] for m in mode))):
+            raise MadGraph5Error("Mode '%s' not reckonized"%mode+
+                                                " in function apply_log_tweak.")
+        
+        model_path = pjoin(proc_path,'Source','MODEL')
+        directories = glob.glob(pjoin(proc_path,'SubProcesses','P0_*'))
+        if directories and os.path.isdir(directories[0]):
+            exe_path = directories[0]
+        else:
+            raise MadGraph5Error, 'Could not find a process executable '+\
+                                                      'directory in %s'%proc_dir
+        bu_path = pjoin(model_path, 'model_functions.f__backUp__')
+        
+        if mode=='default':
+            # Restore the default source file model_function.f
+            if not os.path.isfile(bu_path):
+                raise MadGraph5Error, 'Back up file %s could not be found.'%bu_path
+            shutil.move(bu_path, pjoin(model_path, 'model_functions.f'))
+            return
+
+        if mode=='recompile':
+            try:
+                os.remove(pjoin(model_path,'model_functions.o'))
+                os.remove(pjoin(proc_path,'lib','libmodel.a'))
+            except:
+                pass    
+            misc.compile(cwd=model_path)
+            # Remove the executable to insure proper recompilation
+            try:
+                os.remove(pjoin(exe_path,'check'))
+            except:
+                pass
+            misc.compile(arg=['check'], cwd=exe_path)
+            return
+        
+        if mode[0]==mode[1]:
+            return
+        
+        # Now change the logs
+        mp_prefix = 'MP_'
+        target_line = 'FUNCTION %%sREG%s(ARG)'%mode[0].lower()
+
+        # Make sure to create a backup
+        if not os.path.isfile(bu_path):
+            shutil.copy(pjoin(model_path, 'model_functions.f'), bu_path)            
+        model_functions = open(pjoin(model_path,'model_functions.f'),'r')
+        
+        new_model_functions = []
+        has_replaced        = False
+        just_replaced       = False
+        find_one_replacement= False
+        mp_mode             = None
+        suffix = {'log':'','logp':r'\s*\+\s*TWOPII','logm':r'\s*\-\s*TWOPII'}
+        replace_regex=r'^\s*%%sREG%s\s*=\s*LOG\(ARG\)%s'%(mode[0],suffix[mode[0]])
+        for line in model_functions:
+            # Make sure to skip split lines after the replacement
+            if just_replaced:
+                if not re.match(r'\s{6}', line):
+                    continue
+                else:
+                    just_replaced = False
+            if mp_mode is None:
+                # We are looking for the start of the function
+                new_model_functions.append(line)
+                if (target_line%mp_prefix).lower() in line.lower():
+                    mp_mode       = mp_prefix
+                elif (target_line%'').lower() in line.lower():
+                    mp_mode       = ''
+            else:
+                # Now apply the substitution
+                if not has_replaced and re.match(replace_regex%mp_mode,line,
+                                                                 re.IGNORECASE):
+                    # Apply the replacement
+                    if mode[0]=='log':
+                        if mp_mode=='':
+                            new_line =\
+"""      if(dble(arg).lt.0.0d0.and.dimag(arg).gt.0.0d0)then
+        reg%s=log(arg) %s TWOPII
+      else
+        reg%s=log(arg)
+      endif\n"""%(mode[0],'+' if mode[1]=='logp' else '-',mode[0])
+                        else:
+                            new_line =\
+"""      if(real(arg,kind=16).lt.0.0e0_16.and.imagpart(arg).lt.0.0e0_16)then
+        mp_reg%s=log(arg) %s TWOPII
+      else
+        mp_reg%s=log(arg)
+      endif\n"""%(mode[0],'+' if mode[1]=='logp' else '-',mode[0])
+                    else:
+                        new_line = ' '*6+"%sreg%s=log(arg) %s\n"%(mp_mode,mode[0],
+      ('' if mode[1]=='log' else ('+TWOPII' if mode[1]=='logp' else '-TWOPII')))
+                    new_model_functions.append(new_line)
+                    just_replaced = True
+                    has_replaced  = True
+                    find_one_replacement = True
+                else:
+                    new_model_functions.append(line)
+                    if re.match(r'^\s*END\s*$',line,re.IGNORECASE):
+                        mp_mode      = None
+                        has_replaced = False
+        
+        if not find_one_replacement:
+            logger.warning('No replacement was found/performed for token '+
+                                                  "'%s->%s'."%(mode[0],mode[1]))
+        else:
+            open(pjoin(model_path,'model_functions.f'),'w').\
+                                             write(''.join(new_model_functions))
+        return          
+                
     def setup_ward_check(self, working_dir, file_names, mp = False):
         """ Modify loop_matrix.f so to have one external massless gauge boson
         polarization vector turned into its momentum. It is not a pretty and 
@@ -924,7 +1100,7 @@
         file.close()
 
     def setup_process(self, matrix_element, export_dir, reusing = False,
-                                      param_card = None,MLOptions={},clean=True):
+                                      param_card = None, MLOptions={},clean=True):
         """ Output the matrix_element in argument and perform the initialization
         while providing some details about the output in the dictionary returned. 
         Returns None if anything fails"""
@@ -993,8 +1169,8 @@
             else:
                 param_card.write(pjoin(export_dir,'Cards','param_card.dat'))
                 
-        # First Initialize filters (in later versions where this will be done
-        # at generation time, it can be skipped)
+        # First Initialize filters (in later versions where this will hopefully
+        # be done at generation time, then it will be able to skip it)
         MadLoopInitializer.fix_PSPoint_in_check(pjoin(export_dir,'SubProcesses'),
                                                    read_ps = False, npoints = 4)
         self.fix_MadLoopParamCard(pjoin(export_dir,'Cards'),
@@ -1225,45 +1401,16 @@
                 raise MadGraph5Error("Rotation id %i not implemented"%rotation)
             
             return '\n'.join([' '.join(['%.16E'%pi for pi in p]) for p in p_out])
-        
+            
         def pick_PS_point(proc, options):
             """ Randomly generate a PS point and make sure it is eligible. Then
             return it. Users can edit the cuts here if they want."""
-            def Pt(pmom):
-                """ Computes the pt of a 4-momentum"""
-                return math.sqrt(pmom[1]**2+pmom[2]**2)
-            def DeltaR(p1,p2):
-                """ Computes the DeltaR between two 4-momenta"""
-                # First compute pseudo-rapidities
-                p1_vec=math.sqrt(p1[1]**2+p1[2]**2+p1[3]**2)
-                p2_vec=math.sqrt(p2[1]**2+p2[2]**2+p2[3]**2)    
-                eta1=0.5*math.log((p1_vec+p1[3])/(p1_vec-p1[3]))
-                eta2=0.5*math.log((p2_vec+p2[3])/(p2_vec-p2[3]))
-                # Then azimutal angle phi
-                phi1=math.atan2(p1[2],p1[1])
-                phi2=math.atan2(p2[2],p2[1])
-                dphi=abs(phi2-phi1)
-                # Take the wraparound factor into account
-                dphi=abs(abs(dphi-math.pi)-math.pi)
-                # Now return deltaR
-                return math.sqrt(dphi**2+(eta2-eta1)**2)
 
-            def pass_cuts(p):
-                """ Defines the cut a PS point must pass"""
-                for i, pmom in enumerate(p[2:]):
-                    # Pt > 50 GeV
-                    if Pt(pmom)<50.0:
-                        return False
-                    # Delta_R ij > 0.5
-                    for pmom2 in p[3+i:]:
-                        if DeltaR(pmom,pmom2)<0.5:
-                            return False
-                return True
             p, w_rambo = self.get_momenta(proc, options)
             if options['events']:
                 return p
             # For 2>1 process, we don't check the cuts of course
-            while (not pass_cuts(p) and  len(p)>3):
+            while (not pass_isolation_cuts(p) and  len(p)>3):
                 p, w_rambo = self.get_momenta(proc, options)
                 
             # For a 2>1 process, it would always be the same PS point,
@@ -1796,13 +1943,30 @@
 # Generate a loop matrix element
 #===============================================================================
 def generate_loop_matrix_element(process_definition, reuse, output_path=None,
-                                                         cmd = FakeInterface()):
+                        cmd = FakeInterface(), proc_name=None, loop_filter=None):
     """ Generate a loop matrix element from the process definition, and returns
     it along with the timing information dictionary.
-    If reuse is True, it reuses the already output directory if found."""
+    If reuse is True, it reuses the already output directory if found.
+    There is the possibility of specifying the proc_name."""
 
-    assert isinstance(process_definition,base_objects.ProcessDefinition)
+    assert isinstance(process_definition,
+                          (base_objects.ProcessDefinition,base_objects.Process))
     assert process_definition.get('perturbation_couplings')!=[]
+
+    if isinstance(process_definition,base_objects.ProcessDefinition):
+        if any(len(l.get('ids'))>1 for l in process_definition.get('legs')):
+            raise InvalidCmd("This check can only be performed on single "+
+                             " processes. (i.e. without multiparticle labels).")
+    
+        isids = [leg.get('ids')[0] for leg in process_definition.get('legs') \
+                  if not leg.get('state')]
+        fsids = [leg.get('ids')[0] for leg in process_definition.get('legs') \
+                 if leg.get('state')]
+    
+        # Now generate a process based on the ProcessDefinition given in argument.
+        process = process_definition.get_process(isids,fsids)
+    else:
+        process = process_definition
     
     if not output_path is None:
         root_path = output_path
@@ -1815,20 +1979,11 @@
               'n_loop_groups': None,
               'n_loop_wfs': None,
               'loop_wfs_ranks': None}
-    
-    if any(len(l.get('ids'))>1 for l in process_definition.get('legs')):
-        raise InvalidCmd("This check can only be performed on single "+
-                         " processes. (i.e. without multiparticle labels).")
-
-    isids = [leg.get('ids')[0] for leg in process_definition.get('legs') \
-              if not leg.get('state')]
-    fsids = [leg.get('ids')[0] for leg in process_definition.get('legs') \
-             if leg.get('state')]
-
-    # Now generate a process based on the ProcessDefinition given in argument.
-    process = process_definition.get_process(isids,fsids)
-    
-    proc_dir = pjoin(root_path,"SAVED"+temp_dir_prefix+"_%s"%(
+
+    if proc_name:
+        proc_dir = pjoin(root_path,proc_name)
+    else:
+        proc_dir = pjoin(root_path,"SAVED"+temp_dir_prefix+"_%s"%(
                                '_'.join(process.shell_string().split('_')[1:])))
     if reuse and os.path.isdir(proc_dir):
         logger.info("Reusing directory %s"%str(proc_dir))
@@ -1838,7 +1993,17 @@
     logger.info("Generating p%s"%process_definition.nice_string()[1:])
 
     start=time.time()
-    amplitude = loop_diagram_generation.LoopAmplitude(process)
+    try:
+        amplitude = loop_diagram_generation.LoopAmplitude(process,
+                                                        loop_filter=loop_filter)
+    except InvalidCmd:
+        # An error about the sanity of the process can be thrown, in which case
+        # we return nothing
+        return time.time()-start, None        
+    if not amplitude.get('diagrams'):
+        # Not matrix eleemnt for this process
+        return time.time()-start, None
+
     # Make sure to disable loop_optimized_output when considering loop induced 
     # processes
     loop_optimized_output = cmd.options['loop_optimized_output']
@@ -1865,7 +2030,7 @@
             timing['loop_wfs_ranks'].append(\
                 len([1 for l in lwfs if \
                                l.get_analytic_info('wavefunction_rank')==rank]))
-    
+
     return timing, matrix_element
 
 #===============================================================================
@@ -1932,7 +2097,6 @@
     keep_folder = reuse
     model=process_definition.get('model')
 
-    
     timing, matrix_element = generate_loop_matrix_element(process_definition,
                                         reuse, output_path=output_path, cmd=cmd)
     reusing = isinstance(matrix_element, base_objects.Process)
@@ -3155,7 +3319,7 @@
     # Generate the HelasMatrixElement for the process
     if not isinstance(amplitude, loop_diagram_generation.LoopAmplitude):
         matrix_element = helas_objects.HelasMatrixElement(amplitude,
-                                                      gen_color = True)
+                                                               gen_color = True)
     else:
         matrix_element = loop_helas_objects.LoopHelasMatrixElement(amplitude,
                                        optimized_output = evaluator.loop_optimized_output)
@@ -3336,6 +3500,1148 @@
     else:
         raise InvalidCmd("processes is of non-supported format")
 
+#===============================================================================
+# check_cms
+#===============================================================================
+def check_complex_mass_scheme(process_line, param_card=None, cuttools="",tir={}, 
+         cmd = FakeInterface(), output_path=None, MLOptions = {}, options={}):
+    """Check complex mass scheme consistency in the offshell region of s-channels
+    detected for this process, by varying the expansion paramer consistently
+    with the corresponding width and making sure that the difference between
+    the complex mass-scheme and the narrow-width approximation is higher order.
+    """
+
+    if not isinstance(process_line, str):
+        raise InvalidCmd("Proces definition must be given as a stirng for this check")
+
+    # Generate a list of unique processes in the NWA scheme
+    cmd.do_set('complex_mass_scheme False', log=False)
+    #cmd.do_import('model loop_qcd_qed_sm-NWA')
+    multiprocess_nwa = cmd.extract_process(process_line)
+
+    # Change the option 'recompute_width' to the optimal value if set to 'auto'.
+    has_FRdecay = os.path.isfile(pjoin(cmd._curr_model.get('modelpath'),
+                                                                   'decays.py'))
+
+    if options['recompute_width']=='auto':
+        if multiprocess_nwa.get('perturbation_couplings')!=[]:
+            # NLO, so it is necessary to have the correct LO width for the check
+            options['recompute_width'] = 'first_time'
+        else:
+            options['recompute_width'] = 'never'
+
+    # Some warnings
+    if options['recompute_width'] in ['first_time', 'always'] and \
+                             not has_FRdecay and not 'cached_widths' in options:
+        logger.info('The LO widths will need to be recomputed but the '+
+         'model considered does not appear to have a decay module.\nThe widths'+
+         ' will need to be computed numerically and it will slow down the test.\n'+
+         'Consider using a param_card already specifying correct LO widths and'+
+         " adding the option --recompute_width=never when doing this check.")
+
+    if options['recompute_width']=='never' and \
+        any(order in multiprocess_nwa.get('perturbation_couplings') for order in
+                                                   options['expansion_orders']):
+        logger.warning('You chose not to recompute the widths while including'+
+          ' loop corrections. The check will be successful only if the width'+\
+          ' specified in the default param_card is LO accurate (Remember that'+\
+          ' the default values of alpha_s and awem1 are set to 0.1 and 10.0'+\
+          ' respectively by default).')
+
+    # Reload the model including the decay.py to have efficient MadWidth if
+    # possible (this model will be directly given to MadWidth. Notice that 
+    # this will not be needed for the CMS run because MadWidth is not supposed
+    # to be used there (the widths should be recycled from those of the NWA run).
+    if options['recompute_width'] in ['first_time', 'always'] and has_FRdecay:
+        modelname = cmd._curr_model.get('modelpath+restriction')
+        with misc.MuteLogger(['madgraph'], ['INFO']):
+            model = import_ufo.import_model(modelname, decay=True,
+                                                      complex_mass_scheme=False)
+        multiprocess_nwa.set('model', model)
+
+    run_options = copy.deepcopy(options)
+
+    # Set the seed if chosen by user
+    if options['seed'] > 0:
+        random.seed(options['seed'])
+    
+    # Add useful entries
+    run_options['param_card'] = param_card
+    if isinstance(cmd, FakeInterface):
+        raise MadGraph5Error, "Check CMS cannot be run with a FakeInterface."
+    run_options['cmd']        = cmd
+    run_options['MLOptions']  = MLOptions
+    if output_path:
+        run_options['output_path'] = output_path
+    else:
+        run_options['output_path'] = cmd._mgme_dir
+    
+    # Add the information regarding FR decay for optimal log information
+    run_options['has_FRdecay']     = has_FRdecay
+
+    # And one for caching the widths computed along the way
+    if 'cached_widths' not in run_options:
+        run_options['cached_widths'] = {}
+    # Cached param_cards, first is param_card instance, second is
+    # param_name dictionary
+    run_options['cached_param_card'] = {'NWA':[None,None],'CMS':[None,None]}
+
+    if options['tweak']['name']:
+        logger.info("Now running the CMS check for tweak '%s'"\
+                                                      %options['tweak']['name'])
+
+    model = multiprocess_nwa.get('model')
+    # Make sure all masses are defined as external
+    for particle in model.get('particles'):
+        mass_param = model.get_parameter(particle.get('mass'))
+        if particle.get('mass')!='ZERO' and 'external' not in mass_param.depend:
+            if model.get('name') not in ['sm','loop_sm']:
+                logger.warning("The mass '%s' of particle '%s' is not an external"%\
+              (model.get_parameter(particle.get('mass')).name,particle.get('name'))+\
+              " parameter as required by this check. \nMG5_aMC will try to"+\
+              " modify the model to remedy the situation. No guarantee.")
+            status = model.change_electroweak_mode(set(['mz','mw','alpha']))
+            if not status:
+                raise InvalidCmd('The EW scheme could apparently not be changed'+\
+                  ' so as to have the W-boson mass external. The check cannot'+\
+                  ' proceed.')
+            break
+
+    veto_orders = [order for order in model.get('coupling_orders') if \
+                                       order not in options['expansion_orders']]
+    if len(veto_orders)>0:
+        logger.warning('You did not define any parameter scaling rule for the'+\
+          " coupling orders %s. They will be "%','.join(veto_orders))+\
+          "forced to zero in the tests. Consider adding the scaling rule to"+\
+          "avoid this. (see option '--cms' in 'help check')"
+        for order in veto_orders:
+            multiprocess_nwa.get('orders')[order]==0
+        multiprocess_nwa.set('perturbation_couplings', [order for order in
+        multiprocess_nwa['perturbation_couplings'] if order not in veto_orders])
+
+    if multiprocess_nwa.get('perturbation_couplings')==[]:
+        evaluator = MatrixElementEvaluator(model, param_card,
+                                   cmd=cmd,auth_skipping = False, reuse = True)
+    else:
+        evaluator = LoopMatrixElementTimer(cuttools_dir=cuttools,tir_dir=tir,
+                                           cmd=cmd, model=model,
+                                           param_card=param_card,
+                                           auth_skipping = False, 
+                                           output_path=output_path,
+                                           reuse = False)
+
+    cached_information = []
+    output_nwa = run_multiprocs_no_crossings(check_complex_mass_scheme_process,
+                                           multiprocess_nwa,
+                                           evaluator,
+    # This empty list 'opt' will be passed to the check_complex_mass_scheme_process
+    # function which will fill it with the specification of the particle for which
+    # the the complex mass scheme must be checked. The fact that it is a list
+    # at this stage tells the function check_complex_mass_scheme_process that
+    # we are doing nwa. It will then be converted to a dictionary when doing cms.
+                                           opt = cached_information,
+                                           options=run_options)
+
+    # Make sure to start from fresh for LO runs
+    clean_added_globals(ADDED_GLOBAL)
+
+    # Generate a list of unique processes in the CMS scheme
+    cmd.do_set('complex_mass_scheme True', log=False)
+    #cmd.do_import('model loop_qcd_qed_sm__CMS__-CMS')
+
+    multiprocess_cms = cmd.extract_process(process_line)    
+    model = multiprocess_cms.get('model')
+    # Apply veto
+    if len(veto_orders)>0:
+        for order in veto_orders:
+            multiprocess_cms.get('orders')[order]==0
+        multiprocess_cms.set('perturbation_couplings', [order for order in
+        multiprocess_cms['perturbation_couplings'] if order not in veto_orders])
+        
+    if multiprocess_cms.get('perturbation_couplings')==[]:
+        evaluator = MatrixElementEvaluator(model, param_card,
+                                    cmd=cmd,auth_skipping = False, reuse = True)
+    else:
+        evaluator = LoopMatrixElementTimer(cuttools_dir=cuttools,tir_dir=tir,
+                                           cmd=cmd, model=model,
+                                           param_card=param_card,
+                                           auth_skipping = False, 
+                                           output_path=output_path,
+                                           reuse = False)
+
+    output_cms = run_multiprocs_no_crossings(check_complex_mass_scheme_process,
+                                   multiprocess_cms,
+                                   evaluator,
+                                   # We now substituted the cached information
+                                   opt = dict(cached_information),
+                                   options=run_options)
+
+    if multiprocess_cms.get('perturbation_couplings')!=[] and not options['reuse']:
+        # Clean temporary folders created for the running of the loop processes
+        clean_up(output_path)
+
+    # Now reformat a bit the output by putting the CMS and NWA results together
+    # as values of a dictionary with the process name as key. 
+    # Also a 'processes_order' to list all processes in their order of appearance
+    result = {'ordered_processes':[],'lambdaCMS':options['lambdaCMS']}
+    # Recall what perturbation orders were used
+    result['perturbation_orders']=multiprocess_nwa.get('perturbation_couplings')
+    for i, proc_res in enumerate(output_nwa):
+        result['ordered_processes'].append(proc_res[0])
+        result[proc_res[0]] = {
+                'NWA':proc_res[1]['resonances_result'],
+                'CMS':output_cms[i][1]['resonances_result'],
+                'born_order':proc_res[1]['born_order'],
+                'loop_order':proc_res[1]['loop_order']}
+    
+    # As an optimization we propagate the widths as they could be reused when
+    # using several tweaks
+    options['cached_widths'] = run_options['cached_widths']
+    
+    # Add widths information to the result
+    result['recompute_width'] = options['recompute_width']
+    result['has_FRdecay']     = has_FRdecay
+    result['widths_computed'] = []
+    cached_widths = sorted(options['cached_widths'].items(), key=lambda el: \
+                                                                  abs(el[0][0]))
+    for (pdg, lambda_value), width in cached_widths:
+        if lambda_value != 1.0:
+            continue
+        result['widths_computed'].append((model.get_particle(pdg).get_name(),
+                                                                         width))
+        
+    # Make sure to clear the python ME definitions generated in LO runs
+    clean_added_globals(ADDED_GLOBAL)
+    
+    return result
+
+
+# Check CMS for a given process
+def check_complex_mass_scheme_process(process, evaluator, opt = [], 
+                                                                  options=None):
+    """Check CMS for the process in argument. The options 'opt' is quite important.
+    When opt is a list, it means that we are doing NWA and we are filling the
+    list with the following tuple 
+                       ('proc_name',({'ParticlePDG':ParticlePDG,
+                                      'FinalStateMothersNumbers':set([]), 
+                                      'PS_point_used':[]},...))
+    When opt is a dictionary, we are in the CMS mode and it will be reused then.
+    """
+
+    # a useful logical to check if we are in LO (python on the flight) or 
+    # NLO (output and compilation) mode
+    NLO = process.get('perturbation_couplings') != []
+    
+    def glue_momenta(production, decay):
+        """ Merge together the kinematics for the production of particle 
+        positioned last in the 'production' array with the 1>N 'decay' kinematic' 
+        provided where the decay particle is first."""
+        
+        from MadSpin.decay import momentum
+        
+        full = production[:-1]
+        
+        # Consistency check:
+        # target  =  production[decay_number-1]
+        # boosted = momentum(decay[0][0],decay[0][1],decay[0][2],decay[0][3])
+        # print 'Consistency check ',target==boosted
+        for p in decay[1:]:
+            bp = momentum(*p).boost(momentum(*production[-1]))
+            full.append([bp.E,bp.px,bp.py,bp.pz])
+        
+        return full
+    
+    def find_resonances(diagrams):
+        """ Find all the resonances in the matrix element in argument """
+        
+        model = process['model']
+        resonances_found = []
+
+        for ll, diag in enumerate(diagrams):
+            for amp in diag.get('amplitudes'):
+                # 0 specifies the PDG given to the fake s-channels from 
+                # vertices with more than four legs
+                s_channels, t_channels = amp.\
+                 get_s_and_t_channels(process.get_ninitial(), model, 0)
+                # The s-channel are given from the outmost ones going inward as
+                # vertices, so we must replace parent legs with the outermost ones
+                replacement_dict = {}
+                for s_channel in s_channels:
+                    new_resonance = {
+                        'ParticlePDG':s_channel.get('legs')[-1].get('id'),
+                        'FSMothersNumbers':[],
+                        'PS_point_used':[]}
+                    for leg in s_channel.get('legs')[:-1]:
+                        if leg.get('number')>0:
+                            new_resonance['FSMothersNumbers'].append(
+                                                            leg.get('number'))
+                        else:
+                            try:
+                                new_resonance['FSMothersNumbers'].extend(
+                                            replacement_dict[leg.get('number')])
+                            except KeyError:
+                                raise Exception, 'The following diagram '+\
+                                              'is malformed:'+diag.nice_string()
+                                               
+                    replacement_dict[s_channel.get('legs')[-1].get('number')] = \
+                                               new_resonance['FSMothersNumbers']
+                    new_resonance['FSMothersNumbers'] = set(
+                                              new_resonance['FSMothersNumbers'])
+                    if new_resonance not in resonances_found:
+                        resonances_found.append(new_resonance)
+
+        # Now we setup the phase-space point for each resonance found
+        kept_resonances = []
+        for resonance in resonances_found:
+            # Discard fake s-channels
+            if resonance['ParticlePDG'] == 0:
+                continue
+
+            # Discard if the particle appears in the final state
+            if abs(resonance['ParticlePDG']) in \
+                                [abs(l.get('id')) for l in process.get('legs')]:
+                continue
+
+            mass_string = evaluator.full_model.get_particle(
+                                           resonance['ParticlePDG']).get('mass')
+            mass  = evaluator.full_model.get('parameter_dict')[mass_string].real
+            # Discard massless s-channels
+            if mass==0.0:
+                continue
+            
+            width_string = evaluator.full_model.get_particle(
+                                           resonance['ParticlePDG']).get('width')
+            width  = evaluator.full_model.get('parameter_dict')[width_string].real
+
+            # Discard stable s-channels
+            if width==0.0:
+                continue
+
+            final_state_energy = sum(
+                evaluator.full_model.get('parameter_dict')[
+                evaluator.full_model.get_particle(l.get('id')).get('mass')].real
+                for l in process.get('legs') if l.get('number') in 
+                                                  resonance['FSMothersNumbers'])
+            
+            # Choose the offshellness
+            special_mass = (1.0 + options['offshellness'])*mass
+            
+            # Discard impossible kinematics
+            if special_mass<final_state_energy:
+                raise InvalidCmd('The offshellness specified (%s) is such'\
+                  %options['offshellness']+' that the resulting kinematic is '+\
+                  'impossible for resonance %s %s.'%(evaluator.full_model.
+                           get_particle(resonance['ParticlePDG']).get_name(),
+                                      str(list(resonance['FSMothersNumbers']))))
+                continue
+            
+            # Add it to the list of accepted resonances
+            kept_resonances.append(resonance)
+            
+        for resonance in kept_resonances:
+            # Chose the PS point for the resonance
+            set_PSpoint(resonance, force_other_res_offshell=kept_resonances)
+
+#        misc.sprint(kept_resonances)
+#        misc.sprint(len(kept_resonances))
+        return tuple(kept_resonances)
+
+    def set_PSpoint(resonance, force_other_res_offshell=[], 
+                                allow_energy_increase=1.5, isolation_cuts=True):
+        """ Starting from the specified resonance, construct a phase space point
+        for it and possibly also enforce other resonances to be onshell. Possibly
+        allow to progressively increase enregy by steps of the integer specified
+        (negative float to forbid it) and possible enforce default isolation cuts
+        as well."""
+        
+        def invmass(momenta):
+            """ Computes the invariant mass of a list of momenta."""
+            ptot = [sum(p[i] for p in momenta) for i in range(4)]
+            return math.sqrt(ptot[0]**2-ptot[1]**2-ptot[2]**2-ptot[3]**2)
+        
+        model = evaluator.full_model
+        def getmass(pdg):
+            """ Returns the mass of a particle given the current model and its
+            pdg given in argument."""
+            return model.get('parameter_dict')[
+                                       model.get_particle(pdg).get('mass')].real
+
+        N_trials                  = 0
+        max_trial                 = 1e4
+        nstep_for_energy_increase = 1e3
+        PS_point_found            = None
+        if options['offshellness'] > 0.0:
+            offshellness              = options['offshellness']
+        else:
+            # We must undershoot the offshellness since one needs more 
+            # energy than the target mass to have a valid PS point. So we
+            # start with an offshellness 4 times larger, and progressively reduce
+            # it later
+            offshellness = (0.25*(options['offshellness']+1.0))-1.0
+        
+        # When offshellness is negative, it is progressively decreased every
+        # nstep_for_energy_increase attempts (not increased!), so it is more
+        # dangerous, and we therefore want the steps to be smaller
+        if options['offshellness'] < 0.0:
+            energy_increase = math.sqrt(allow_energy_increase)
+        else:
+            energy_increase = allow_energy_increase
+        # Make sure to remove the resonance itself from force_other_res_offshell
+        other_res_offshell = [res for res in force_other_res_offshell if 
+                                                                 res!=resonance]
+
+        # Now play it smart on finding starting energy and offshellness and 
+        # register all resonance masses
+        all_other_res_masses = [getmass(res['ParticlePDG'])
+                                                  for res in other_res_offshell]
+        resonance_mass = getmass(resonance['ParticlePDG'])
+
+        str_res = '%s %s'%(model.get_particle(
+                            resonance['ParticlePDG']).get_name(),
+                                       str(list(resonance['FSMothersNumbers'])))
+        leg_number_to_leg = dict((l.get('number'),l) for l in process.get('legs'))
+        # Find what is the minimum possible offshellness given
+        # the mass of the daughters of this resonance.
+        # This will only be relevant when options['offshellness'] is negative
+        daughter_masses = sum(getmass(leg_number_to_leg[\
+                 number].get('id')) for number in resonance['FSMothersNumbers'])
+        min_offshellnes = 4.0*((daughter_masses*1.2)/resonance_mass)-1.0
+
+        # Compute the minimal energy given the external states, add 20% to leave
+        # enough phase-space
+        min_energy = max(sum(getmass(l.get('id')) for l in \
+                                  process.get('legs') if l.get('state')==True),
+                         sum(getmass(l.get('id')) for l in \
+                                  process.get('legs') if l.get('state')==False))
+        
+        # List all other offshellnesses of the potential daughters of this 
+        # resonance
+        daughter_offshellnesses = [(1.0+options['offshellness'])*mass 
+              for i, mass in enumerate(all_other_res_masses) if 
+                      other_res_offshell[i]['FSMothersNumbers'].issubset(
+                                                 resonance['FSMothersNumbers'])]
+        
+        if options['offshellness'] >= 0.0:
+            
+            if len(daughter_offshellnesses)>0:
+                max_mass = max(daughter_offshellnesses)
+                # A factor two to have enough phase-space
+                offshellness = max(2.0*(max_mass/resonance_mass)-1.0,
+                                                        options['offshellness'])
+            
+            max_mass = max([(1.0+options['offshellness'])*mass for mass in \
+                  all_other_res_masses]+[(1.0+offshellness)*resonance_mass])
+            
+            # Account for external_masses too
+            # A factor two to have enough phase-space open
+            target = max(min_energy*1.2,max_mass*2.0)
+            if target > options['energy']:
+                logger.warning("The user-defined energy %f seems "%options['energy']+
+              " insufficient to reach the minimum propagator invariant mass "+
+              "%f required for the chosen offshellness %f."%(max_mass,
+               options['offshellness']) + " Energy reset to %f."%target)
+                options['energy'] = target
+                
+        else:
+            if len(daughter_offshellnesses) > 0:
+                min_mass = min(daughter_offshellnesses)
+                # A factor one half to have enough phase-space
+                offshellness = min(0.25*(min_mass/resonance_mass)-1.0,
+                                                        options['offshellness'])
+            
+            # Make sure the chosen offshellness leaves enough energy to produce
+            # the daughter masses
+            if (1.0+offshellness)*resonance_mass < daughter_masses*1.2:
+                msg = 'The resonance %s cannot accomodate'%str_res+\
+              ' an offshellness of %f because the daughter'%options['offshellness']+\
+              ' masses are %f.'%daughter_masses
+                if options['offshellness']<min_offshellnes:
+                    msg += ' Try again with an offshellness'+\
+                  ' smaller (in absolute value) of at least %f.'%min_offshellnes
+                else:
+                  msg += ' Try again with a smalled offshellness (in absolute value).'
+                raise InvalidCmd(msg)
+            
+            min_mass = min([(1.0+options['offshellness'])*mass for mass in \
+                      all_other_res_masses]+[(1.0+offshellness)*resonance_mass])
+            # Account for external_masses too
+            # A factor two to have enough phase-space open
+            if 2.0*min_mass < options['energy']:
+                new_energy = max(min_energy*1.2, 2.0*min_mass)
+                logger.warning("The user-defined energy %f seems "%options['energy']+
+                  " too large to not overshoot the maximum propagator invariant mass "+
+                  "%f required for the chosen offshellness %f."%(min_mass,
+                   options['offshellness']) + " Energy reset to %f."%new_energy)
+                options['energy'] = new_energy  
+        
+        if options['offshellness'] < 0.0 and options['energy'] >= min_mass:
+            logger.debug("The target energy is not compatible with the mass"+
+              " of the external states for this process (%f). It is "%min_mass+
+                 "unlikely that a valid kinematic configuration will be found.")
+        
+        if options['offshellness']<0.0 and offshellness<options['offshellness'] or \
+           options['offshellness']>0.0 and offshellness>options['offshellness']:
+            logger.debug("Offshellness increased to %f"%offshellness+
+                " so as to try to find a kinematical configuration with"+
+                " offshellness at least equal to %f"%options['offshellness']+
+                                                         " for all resonances.")
+
+        start_energy = options['energy']        
+        while N_trials<max_trial:
+            N_trials += 1
+            if N_trials%nstep_for_energy_increase==0:
+                if allow_energy_increase > 0.0:
+                    old_offshellness = offshellness
+                    if offshellness > 0.0:
+                        options['energy'] *= energy_increase
+                        offshellness      *= energy_increase
+                    else:
+                        options['energy'] = max(options['energy']/energy_increase, 
+                                                                 min_energy*1.2)
+                        offshellness = max(min_offshellnes,
+                                       ((offshellness+1.0)/energy_increase)-1.0)
+                    if old_offshellness!=offshellness:
+                        logger.debug('Trying to find a valid kinematic'+\
+                           " configuration for resonance '%s'"%str_res+\
+                             ' with increased offshellness %f'%offshellness)
+
+            candidate = get_PSpoint_for_resonance(resonance, offshellness)
+            pass_offshell_test = True
+            for i, res in enumerate(other_res_offshell):
+                # Make sure other resonances are sufficiently offshell too
+                if offshellness > 0.0:
+                    if invmass([candidate[j-1] for j in res['FSMothersNumbers']]) <\
+                        ((1.0+options['offshellness'])*all_other_res_masses[i]):
+                        pass_offshell_test = False
+                        break
+                else:
+                    if invmass([candidate[j-1] for j in res['FSMothersNumbers']]) >\
+                        ((1.0+options['offshellness'])*all_other_res_masses[i]):
+                        pass_offshell_test = False
+                        break
+            if not pass_offshell_test:
+                continue
+            # Make sure it is isolated
+            if isolation_cuts:
+                # Set ptcut to 5% of total energy
+                if not evaluator.pass_isolation_cuts(candidate,
+                      ptcut=0.05*invmass([candidate[0],candidate[1]]), drcut=0.4):
+                    continue
+            PS_point_found = candidate
+            break
+        
+        # Restore the initial energy setup
+        options['energy'] = start_energy
+
+        if PS_point_found is None:
+            err_msg = 'Could not find a valid PS point in %d'%max_trial+\
+                ' trials. Try increasing the energy, modify the offshellness '+\
+                'or relax some constraints.'
+            if options['offshellness']<0.0:
+                err_msg +='Try with a positive offshellness instead (or a '+\
+                                       'negative one of smaller absolute value)'
+            raise InvalidCmd, err_msg
+        else:
+#            misc.sprint('PS point found in %s trials.'%N_trials)
+#            misc.sprint(PS_point_found)
+            resonance['offshellnesses'] = []
+            all_other_res_masses = [resonance_mass] + all_other_res_masses
+            other_res_offshell   = [resonance] + other_res_offshell
+            for i, res in enumerate(other_res_offshell):
+                if i==0:
+                    res_str = 'self'
+                else:
+                    res_str = '%s %s'%(model.get_particle(
+                                         res['ParticlePDG']).get_name(),
+                                             str(list(res['FSMothersNumbers'])))
+                resonance['offshellnesses'].append((res_str,(
+                    (invmass([PS_point_found[j-1] for j in 
+                       res['FSMothersNumbers']])/all_other_res_masses[i])-1.0)))
+
+            resonance['PS_point_used'] = PS_point_found
+        
+    def get_PSpoint_for_resonance(resonance, offshellness = options['offshellness']):
+        """ Assigns a kinematic configuration to the resonance dictionary 
+        given in argument."""            
+
+        # Get the particle mass
+        mass_string = evaluator.full_model.get_particle(
+                                       resonance['ParticlePDG']).get('mass')
+        mass  = evaluator.full_model.get('parameter_dict')[mass_string].real
+        
+        # Choose the offshellness
+        special_mass = (1.0 + offshellness)*mass
+        
+        # Create a fake production and decay process
+        prod_proc = base_objects.Process({'legs':base_objects.LegList(
+             copy.copy(leg) for leg in process.get('legs') if 
+                   leg.get('number') not in resonance['FSMothersNumbers'])})
+        # Add the resonant particle as a final state
+        # ID set to 0 since its mass will be forced
+        # Number set so as to be first in the list in get_momenta
+        prod_proc.get('legs').append(base_objects.Leg({
+                'number':max(l.get('number') for l in process.get('legs'))+1,
+                'state':True,
+                'id':0}))
+        # now the decay process
+        decay_proc = base_objects.Process({'legs':base_objects.LegList(
+           copy.copy(leg) for leg in process.get('legs') if leg.get('number') 
+             in resonance['FSMothersNumbers'] and not leg.get('state')==False)})
+        # Add the resonant particle as an initial state
+        # ID set to 0 since its mass will be forced
+        # Number set to -1 as well so as to be sure it appears first in 
+        # get_momenta
+        decay_proc.get('legs').insert(0,base_objects.Leg({
+                'number':-1,
+                'state':False,
+                'id':0}))
+        prod_kinematic = evaluator.get_momenta(prod_proc, options=options,
+                                               special_mass=special_mass)[0]
+        decay_kinematic = evaluator.get_momenta(decay_proc, options=options, 
+                                               special_mass=special_mass)[0]
+        momenta = glue_momenta(prod_kinematic,decay_kinematic)
+        # Reshuffle the momentum so as to put it back in the order specified
+        # in the process definition.
+        # First the production momenta, without the special decayed particle
+        ordered_momenta = [(prod_proc.get('legs')[i].get('number'),momenta[i])
+                for i in range(len(prod_proc.get('legs'))-1)]
+        # And then the decay ones.
+        ordered_momenta += [(decay_proc.get('legs')[-i].get('number'),
+                 momenta[-i]) for i in range(1,len(decay_proc.get('legs')))]
+
+        # Return the PSpoint found in the right order
+        return [m[1] for m in sorted(ordered_momenta, key = lambda el: el[0])]
+        
+        # misc.sprint(resonance['PS_point_used'])        
+    
+    @misc.mute_logger()
+    def get_width(PDG, lambdaCMS, param_card):
+        """ Returns the width to use for particle with absolute PDG 'PDG' and
+        for the the lambdaCMS value 'lambdaCMS' using the cache if possible."""
+
+        # If an unstable particle is in the external state, then set its width
+        # to zero and don't cache the result of course.
+        if abs(PDG) in [abs(leg.get('id')) for leg in process.get('legs')]:
+            return 0.0
+
+        particle = evaluator.full_model.get_particle(PDG)
+        
+        # If it is a goldstone or a ghost, retur zero as its width should anyway
+        # not be independent. The test for checking if it is a goldstone or not
+        # will be made more general in 2.3.3 when it will be an attribute of the
+        # particle class. Normally the first statement will crash in that verison
+        # because it is not .get('ghost'). This is done in purpose so as to be
+        # sure to fix the goldstone check in due time.
+        if particle['ghost'] or particle.get_name() in ['g0','g+','g-']:
+            return 0.0
+
+        # If its width is analytically set to zero, then return zero right away
+        if particle.get('width')=='ZERO':
+            return 0.0
+    
+        if (PDG,lambdaCMS) in options['cached_widths']:
+            return options['cached_widths'][(PDG,lambdaCMS)]
+
+        if options['recompute_width'] == 'never':
+            width = evaluator.full_model.\
+                               get('parameter_dict')[particle.get('width')].real
+        else:
+            # Crash if we are doing CMS and the width was not found and recycled above
+            if aloha.complex_mass:
+                raise MadGraph5Error, "The width for particle with PDG %d and"%PDG+\
+                  " lambdaCMS=%f should have already been "%lambdaCMS+\
+                  "computed during the NWA run."
+
+        # Use MadWith
+        if options['recompute_width'] in ['always','first_time']:
+            particle_name = particle.get_name()
+            with misc.TMP_directory(dir=options['output_path']) as path:
+                param_card.write(pjoin(path,'tmp.dat'))
+                # 2-body decay is the maximum that should be considered for NLO check.
+                # The default 1% accuracy is not enough when pushing to small
+                # lambdaCMS values, we need 1 per mil at least.
+                command = '%s --output=%s'%(particle_name,pjoin(path,'tmp.dat'))+\
+                    ' --path=%s --body_decay=2'%pjoin(path,'tmp.dat')+\
+                    ' --precision_channel=0.001'
+#                misc.sprint(command)
+                param_card.write(pjoin(options['output_path'],'tmp.dat'))
+                # The MG5 command get_width will change the cmd._curr_model
+                # and the cmd._curr_fortran_model which what we specified, so 
+                # we must make sure to restore them after it finishes
+                orig_model = options['cmd']._curr_model
+                orig_fortran_model = options['cmd']._curr_fortran_model
+                options['cmd'].do_compute_widths(command, evaluator.full_model)
+                # Restore the models
+                options['cmd']._curr_model = orig_model
+                options['cmd']._curr_fortran_model = orig_fortran_model
+                # Restore the width of the model passed in argument since
+                # MadWidth will automatically update the width
+                evaluator.full_model.set_parameters_and_couplings(
+                                                          param_card=param_card)
+                try:
+                    tmp_param_card = check_param_card.ParamCard(pjoin(path,'tmp.dat'))
+                except:
+                    raise MadGraph5Error, 'Error occured during width '+\
+                       'computation with command:\n   compute_widths %s'%command                   
+                width = tmp_param_card['decay'].get(PDG).value
+#                misc.sprint('lambdaCMS checked is', lambdaCMS,
+#                                                   'for particle',particle_name)
+#                misc.sprint('Width obtained :', width)
+#                if lambdaCMS != 1.0:
+#                    misc.sprint('Naively expected (lin. scaling) :',
+#                                  options['cached_widths'][(PDG,1.0)]*lambdaCMS)
+                
+        if options['recompute_width'] in ['never','first_time']:
+            # Assume linear scaling of the width
+            for lam in options['lambdaCMS']:
+                options['cached_widths'][(PDG,lam)]=width*(lam/lambdaCMS)
+        else:
+            options['cached_widths'][(PDG,lambdaCMS)] = width
+        
+        return options['cached_widths'][(PDG,lambdaCMS)]
+            
+    def get_order(diagrams, diagsName):
+        """Compute the common summed of coupling orders used for this cms check
+         in the diagrams specified. When inconsistency occurs, use orderName
+         in the warning message if throwm."""
+         
+        orders = set([])
+        for diag in diagrams:
+            diag_orders = diag.calculate_orders()
+            orders.add(sum((diag_orders[order] if order in diag_orders else 0)
+                                      for order in options['expansion_orders']))
+            if len(orders)>1:
+                logger.warning(msg%('%s '%diagsName,str(orders)))
+                return min(list(orders))
+            else:
+                return list(orders)[0]
+         
+    MLoptions = copy.copy(options['MLOptions'])
+    # Make sure double-check helicities is set to False
+    MLoptions['DoubleCheckHelicityFilter'] = False
+    
+    # Apply the seed tweak if present
+    for tweak in options['tweak']['custom']:
+        if tweak.startswith('seed'):
+            try:
+                new_seed = int(tweak[4:])
+            except ValueError:
+                raise MadGraph5Error, "Seed '%s' is not of the right format 'seed<int>'."%tweak
+            random.seed(new_seed)
+                
+    mode = 'CMS' if aloha.complex_mass else 'NWA'
+    for i, leg in enumerate(process.get('legs')):
+        leg.set('number', i+1)
+
+    logger.info("Running CMS check for process %s  (now doing %s scheme)" % \
+                  ( process.nice_string().replace('Process:', 'process'), mode))
+    
+    proc_dir = None
+    resonances = None
+    warning_msg = "All %sdiagrams do not share the same sum of orders "+\
+            "%s; found %%s."%(','.join(options['expansion_orders']))+\
+            " This potentially problematic for the CMS check."
+    if NLO:
+        # We must first create the matrix element, export it and set it up.
+        # If the reuse option is specified, it will be recycled.
+        
+        if options['name']=='auto':
+            proc_name = "%s%s_%s%s__%s__"%(('SAVED' if options['reuse'] else ''),
+         temp_dir_prefix, '_'.join(process.shell_string().split('_')[1:]), 
+         ('_' if process.get('perturbation_couplings') else '')+
+         '_'.join(process.get('perturbation_couplings')),mode)
+        else:
+            proc_name = "%s%s_%s__%s__"%(('SAVED' if options['reuse'] else ''),
+                                          temp_dir_prefix,options['name'], mode)
+        # Generate the ME
+        timing, matrix_element = generate_loop_matrix_element(process, 
+                options['reuse'], output_path=options['output_path'], 
+                           cmd = options['cmd'], proc_name=proc_name, 
+                                             loop_filter=options['loop_filter'])
+        if matrix_element is None:
+            # No diagrams for this process
+            return None
+
+        reusing = isinstance(matrix_element, base_objects.Process)
+        proc_dir = pjoin(options['output_path'],proc_name)
+
+        # Export the ME
+        infos = evaluator.setup_process(matrix_element, proc_dir, 
+                        reusing = reusing, param_card = options['param_card'], 
+                                                            MLOptions=MLoptions)
+        # Make sure the right MLoptions are set
+        evaluator.fix_MadLoopParamCard(pjoin(proc_dir,'Cards'),
+                              mp = None, loop_filter = True,MLOptions=MLoptions)
+        
+        # Make sure to start from fresh if previous run was stopped
+        tmp_card_backup = pjoin(proc_dir,'Cards','param_card.dat__TemporaryBackup__')
+        if os.path.isfile(tmp_card_backup):
+            # Run was stopped mid-way, we must then restore the original card
+            logger.info("Last run in process '%s' apparently aborted."%proc_dir+\
+                           " Now reverting 'param_card.dat' to its original value.")
+            shutil.copy(tmp_card_backup, pjoin(proc_dir, 'Cards','param_card.dat'))
+        else:
+            # Create a temporary backup which will be cleaned if the run ends properly
+            shutil.copy(pjoin(proc_dir,'Cards','param_card.dat'), tmp_card_backup)
+        # Now do the same with model_functions.f
+        tmp_modelfunc_backup = pjoin(proc_dir,'Source','MODEL',
+                                         'model_functions.f__TemporaryBackup__')
+        if os.path.isfile(tmp_modelfunc_backup):
+            # Run was stopped mid-way, we must then restore the model functions
+            logger.info("Last run in process '%s' apparently aborted."%proc_dir+\
+                    " Now reverting 'model_functions.f' to its original value.")
+            shutil.copy(tmp_modelfunc_backup, pjoin(proc_dir,'Source','MODEL',
+                                                           'model_functions.f'))
+            evaluator.apply_log_tweak(proc_dir, 'recompile')
+        else:
+            # Create a temporary backup which will be cleaned if the run ends properly
+            shutil.copy(pjoin(proc_dir,'Source','MODEL','model_functions.f'),
+                                                           tmp_modelfunc_backup)
+
+        # Make sure to setup correctly the helicity
+        MadLoopInitializer.fix_PSPoint_in_check(pjoin(proc_dir,'SubProcesses'),
+              read_ps = True, npoints = 1, hel_config = options['helicity'], 
+                                           split_orders=options['split_orders'])
+   
+        # And recompile while making sure to recreate the executable and 
+        # modified sources
+        for dir in glob.glob(pjoin(proc_dir,'SubProcesses','P*_*')):
+            if not (re.search(r'.*P\d+_\w*$', dir) or not os.path.isdir(dir)):
+                continue
+            try:
+                os.remove(pjoin(dir,'check'))
+                os.remove(pjoin(dir,'check_sa.o'))
+            except OSError:
+                pass
+            # Now run make
+            with open(os.devnull, 'w') as devnull:
+                retcode = subprocess.call(['make','check'],
+                                   cwd=dir, stdout=devnull, stderr=devnull)                     
+            if retcode != 0:
+                raise MadGraph5Error, "Compilation error with "+\
+                                                        "'make check' in %s"%dir
+
+        # Now find all the resonances of the ME, if not saved from a previous run
+        pkl_path = pjoin(proc_dir,'resonance_specs.pkl')
+        if reusing:
+            # We recover the information from the pickle dumped during the
+            # original run
+            if not os.path.isfile(pkl_path):
+                raise InvalidCmd('The folder %s could'%proc_dir+\
+                 " not be reused because the resonance specification file "+
+                                            "'resonance_specs.pkl' is missing.")
+            else:
+                proc_name, born_order, loop_order, resonances = \
+                                       save_load_object.load_from_file(pkl_path)
+                # Make sure to rederive the phase-space point since parameters
+                # such as masses, seed, offshellness could have affected it
+                for res in resonances:
+                    set_PSpoint(res, force_other_res_offshell=resonances)
+
+            # Second run (CMS), we can reuse the information if it is a dictionary
+            if isinstance(opt, list):
+                opt.append((proc_name, resonances))
+            else:
+                resonances = opt
+        else:
+            helas_born_diagrams = matrix_element.get_born_diagrams()
+            if len(helas_born_diagrams)==0:
+                logger.warning('The CMS check for loop-induced process is '+\
+                                  'not yet available (nor is it very interesting).')
+                return None
+            born_order = get_order(helas_born_diagrams,'Born')
+            loop_order = get_order(matrix_element.get_loop_diagrams(),'loop')
+
+            # Second run (CMS), we can reuse the information if it is a dictionary
+            if isinstance(opt, list):
+                opt.append((process.base_string(),find_resonances(helas_born_diagrams)))
+                resonances = opt[-1][1]
+            else:
+                resonances = opt
+            # Save the resonances to a pickle file in the output directory so that
+            # it can potentially be reused.
+            save_load_object.save_to_file(pkl_path, (process.base_string(),
+                                             born_order, loop_order,resonances))
+
+    else:
+        # The LO equivalent
+        try:
+            amplitude = diagram_generation.Amplitude(process)
+        except InvalidCmd:
+            logging.info("No diagrams for %s" % \
+                            process.nice_string().replace('Process', 'process'))
+            return None
+        if not amplitude.get('diagrams'):
+            # This process has no diagrams; go to next process
+            logging.info("No diagrams for %s" % \
+                             process.nice_string().replace('Process', 'process'))
+            return None
+
+        matrix_element = helas_objects.HelasMatrixElement(amplitude,
+                                                                 gen_color=True)
+        diagrams = matrix_element.get('diagrams')
+        born_order = get_order(diagrams,'Born')
+        # Loop order set to -1 indicates an LO result
+        loop_order = -1
+        # Find all the resonances of the ME, if not already given in opt
+        if isinstance(opt, list):
+            opt.append((process.base_string(),find_resonances(diagrams)))
+            resonances = opt[-1][1]
+        else:
+            resonances= opt
+    
+    if len(resonances)==0:
+        logger.info("No resonance found for process %s."\
+                                                         %process.base_string())
+        return None
+    
+    # Cache the default param_card for NLO
+    if not options['cached_param_card'][mode][0]:
+        if NLO:
+            param_card = check_param_card.ParamCard(
+                                       pjoin(proc_dir,'Cards','param_card.dat'))
+        else:
+            param_card = check_param_card.ParamCard(
+                     StringIO.StringIO(evaluator.full_model.write_param_card()))
+        options['cached_param_card'][mode][0] = param_card
+        name2block, _ = AskforEditCard.analyze_param_card(param_card)
+        options['cached_param_card'][mode][1] = name2block
+        
+    else:
+        param_card = options['cached_param_card'][mode][0]
+        name2block = options['cached_param_card'][mode][1]
+
+    # Already add the coupling order for this sqaured ME.
+    if loop_order != -1 and (loop_order+born_order)%2 != 0:
+        raise MadGraph5Error, 'The summed squared matrix element '+\
+                              " order '%d' is not even."%(loop_order+born_order)
+    result = {'born_order':born_order, 
+              'loop_order': (-1 if loop_order==-1 else (loop_order+born_order)/2),
+              'resonances_result':[]}
+
+    # Create a physical backup of the param_card
+    if NLO:
+        try:
+            shutil.copy(pjoin(proc_dir,'Cards','param_card.dat'),
+                             pjoin(proc_dir,'Cards','param_card.dat__backUp__'))
+        except:
+            pass
+
+    # Apply custom tweaks
+    had_log_tweaks=False
+    if NLO:
+        for tweak in options['tweak']['custom']:
+            if tweak.startswith('seed'):
+                continue
+            try:
+                logstart, logend = tweak.split('->')
+            except:
+                raise Madgraph5Error, "Tweak '%s' not reckognized."%tweak
+            if logstart in ['logp','logm', 'log'] and \
+               logend in ['logp','logm', 'log']:
+                if NLO:
+                    evaluator.apply_log_tweak(proc_dir, [logstart, logend])
+                    had_log_tweaks = True
+            else:
+                raise Madgraph5Error, "Tweak '%s' not reckognized."%tweak
+        if had_log_tweaks:
+            evaluator.apply_log_tweak(proc_dir, 'recompile')
+
+    # Select what resonances should be run
+    if options['resonances']=='all':
+        resonances_to_run = resonances
+    elif isinstance(options['resonances'],int):
+        resonances_to_run = resonances[:options['resonances']]    
+    elif isinstance(options['resonances'],list):
+        resonances_to_run = []
+        for res in resonances:
+            for res_selection in options['resonances']:
+                if abs(res['ParticlePDG'])==res_selection[0] and \
+                                 res['FSMothersNumbers']==set(res_selection[1]):
+                    resonances_to_run.append(res)
+                    break
+    else:
+        raise InvalidCmd("Resonance selection '%s' not reckognized"%\
+                                                     str(options['resonances']))
+
+    # Display progressbar both for LO and NLO for now but not when not showing
+    # the plots
+    if (NLO or True) and options['show_plot']:
+        widgets = ['ME evaluations:', pbar.Percentage(), ' ', 
+                                                pbar.Bar(),' ', pbar.ETA(), ' ']
+        progress_bar = pbar.ProgressBar(widgets=widgets, 
+                maxval=len(options['lambdaCMS'])*len(resonances_to_run), fd=sys.stdout)
+        progress_bar.update(0)
+        # Flush stdout to force the progress_bar to appear
+        sys.stdout.flush()
+    else:
+        progress_bar = None
+
+    for resNumber, res in enumerate(resonances_to_run):
+        # First add a dictionary for this resonance to the result with already
+        # one key specifying the resonance
+        result['resonances_result'].append({'resonance':res,'born':[]})
+        if NLO:
+            result['resonances_result'][-1]['finite'] = []
+        # Now scan the different lambdaCMS values
+        for lambdaNumber, lambdaCMS in enumerate(options['lambdaCMS']):
+            # Setup the model for that value of lambdaCMS
+            # The copy constructor below creates a deep copy
+            new_param_card = check_param_card.ParamCard(param_card)
+            # Change all specified parameters
+            for param, replacement in options['expansion_parameters'].items():
+                # Replace the temporary prefix used for evaluation of the 
+                # substitution expression 
+                orig_param = param.replace('__tmpprefix__','')
+                if orig_param not in name2block:
+                    # It can be that some parameter ar in the NWA model but not
+                    # in the CMS, such as the Yukawas for example.
+                    # logger.warning("Unknown parameter '%s' in mode '%s'."%(param,mode))
+                    continue
+                for block, lhaid in name2block[orig_param]:
+                    orig_value = float(param_card[block].get(lhaid).value)
+                    new_value  = eval(replacement,
+                                       {param:orig_value,'lambdacms':lambdaCMS})
+                    new_param_card[block].get(lhaid).value=new_value
+
+            # Apply these changes already (for the purpose of Width computation.
+            # although it is optional since we now provide the new_param_card to
+            # the width computation function.). Also in principle this matters
+            # only in the CMS and there the widths would be reused from their 
+            # prior computation within NWA with zero widths. So, all in all,
+            # the line below is really not crucial, but semantically, it ought
+            # to be there.
+            evaluator.full_model.set_parameters_and_couplings(
+                                                      param_card=new_param_card)
+            # Now compute or recyle all widths
+            for decay in new_param_card['decay'].keys():
+                if mode=='CMS':
+                    new_width = get_width(abs(decay[0]), lambdaCMS, 
+                                                                 new_param_card)
+                else:
+                    new_width = 0.0
+                new_param_card['decay'].get(decay).value= new_width
+
+            # Apply these changes for the purpose of the final computation
+            evaluator.full_model.set_parameters_and_couplings(
+                                                      param_card=new_param_card)
+            if NLO:
+                new_param_card.write(pjoin(proc_dir,'Cards','param_card.dat'))
+                # Write the recomputed widths so that it can potentially be
+                # used for future runs (here for the model in the CMS format)
+                if lambdaCMS==1.0 and mode=='CMS' and \
+                          options['recompute_width'] in ['always','first_time']:
+                    new_param_card.write(pjoin(proc_dir,
+                                    'Cards','param_card.dat_recomputed_widths'))
+                    
+            # If recomputing widths with MadWidths, we want to do it within
+            # the NWA models with zero widths.
+            if mode=='NWA' and (options['recompute_width']=='always' or (
+                  options['recompute_width']=='first_time' and lambdaCMS==1.0)):
+                # The copy constructor below creates a deep copy
+                tmp_param_card = check_param_card.ParamCard(new_param_card)
+                # We don't use the result here, it is just so that it is put
+                # in the cache and reused in the CMS run that follows.
+                for decay in new_param_card['decay'].keys():
+                    particle_name = evaluator.full_model.get_particle(\
+                                                       abs(decay[0])).get_name()
+                    new_width = get_width(abs(decay[0]),lambdaCMS,new_param_card)
+                    tmp_param_card['decay'].get(decay).value = new_width
+                    if not options['has_FRdecay'] and new_width != 0.0:
+                        logger.info('Numerically computed width of particle'+\
+                                        ' %s for lambda=%.4g : %-9.6gGeV'%
+                                            (particle_name,lambdaCMS,new_width))
+
+                # Write the recomputed widths so that it can potentially be
+                # used for future runs (here the model in the NWA format)
+                if lambdaCMS==1.0 and NLO:
+                    tmp_param_card.write(pjoin(proc_dir,
+                                    'Cards','param_card.dat_recomputed_widths'))
+            
+            # Apply the params tweaks
+            for param, replacement in options['tweak']['params'].items():
+               # Replace the temporary prefix used for evaluation of the 
+               # substitution expression 
+               orig_param = param.replace('__tmpprefix__','')
+               # Treat the special keyword 'allwidths'
+               if orig_param.lower() == 'allwidths':
+                    # Apply the rule to all widhts
+                    for decay in new_param_card['decay'].keys():
+                        orig_value = float(new_param_card['decay'].get(decay).value)
+                        new_value = eval(replacement,
+                                       {param:orig_value,'lambdacms':lambdaCMS})
+                        new_param_card['decay'].get(decay).value = new_value
+                    continue
+               if orig_param not in name2block:
+                   # It can be that some parameter are in the NWA model but not
+                   # in the CMS, such as the Yukawas for example.
+                   continue
+               for block, lhaid in name2block[orig_param]:
+                   orig_value = float(new_param_card[block].get(lhaid).value)
+                   new_value  = eval(replacement,
+                                       {param:orig_value,'lambdacms':lambdaCMS})
+                   new_param_card[block].get(lhaid).value=new_value
+            
+            if options['tweak']['params']:
+                # Apply the tweaked param_card one last time
+                evaluator.full_model.set_parameters_and_couplings(
+                                                      param_card=new_param_card)
+                if NLO:
+                    new_param_card.write(pjoin(proc_dir,'Cards','param_card.dat'))
+
+            # Finally ready to compute the matrix element
+            if NLO:
+                ME_res = LoopMatrixElementEvaluator.get_me_value(process, 0, 
+                       proc_dir, PSpoint=res['PS_point_used'], verbose=False, 
+                                           format='dict', skip_compilation=True)
+                # Notice that there is much more information in ME_res. It can
+                # be forwarded to check_complex_mass_scheme in this result
+                # dictionary if necessary for the analysis. (or even the full 
+                # dictionary ME_res can be added).
+                result['resonances_result'][-1]['born'].append(ME_res['born'])
+                result['resonances_result'][-1]['finite'].append(
+                      ME_res['finite']*ME_res['born']*ME_res['alphaS_over_2pi'])
+            else:
+                ME_res = evaluator.evaluate_matrix_element(matrix_element,
+                    p=res['PS_point_used'], auth_skipping=False, output='m2')[0]
+                result['resonances_result'][-1]['born'].append(ME_res)
+            if not progress_bar is None:
+                progress_bar.update(resNumber*len(options['lambdaCMS'])+\
+                                                               (lambdaNumber+1))
+                # Flush to force the printout of the progress_bar to be updated
+                sys.stdout.flush()
+
+    # Restore the original continued log definition if necessary
+    log_reversed = False
+    for tweak in options['tweak']['custom']:
+        if tweak.startswith('log') and had_log_tweaks:
+            if log_reversed:
+                continue
+            if NLO:
+                evaluator.apply_log_tweak(proc_dir, 'default')
+                evaluator.apply_log_tweak(proc_dir, 'recompile')                
+                log_reversed = True
+
+    # Restore the original model parameters
+    evaluator.full_model.set_parameters_and_couplings(param_card=param_card)
+    if NLO:
+        try:
+            shutil.copy(pjoin(proc_dir,'Cards','param_card.dat__backUp__'),
+                                      pjoin(proc_dir,'Cards','param_card.dat'))
+        except:
+            param_card.write(pjoin(proc_dir,'Cards','param_card.dat'))
+    
+    # All should have been restored properly, so we can now clean the temporary
+    # backups
+    try:
+        os.remove(pjoin(proc_dir,'Cards','param_card.dat__TemporaryBackup__'))
+        os.remove(pjoin(proc_dir,'Source','MODEL',
+                                        'model_functions.f__TemporaryBackup__'))
+    except:
+        pass
+
+    return (process.nice_string().replace('Process:', '').strip(),result)
+
 def get_value(process, evaluator, p=None, options=None):
     """Return the value/momentum for a phase space point"""
     
@@ -3677,6 +4983,765 @@
     else: 
         return fail_proc
 
-
-
-
+def CMS_save_path(extension, cms_res, used_model, opts, output_path=None):
+    """Creates a suitable filename for saving these results."""
+    
+    if opts['name']=='auto' and opts['analyze']!='None':
+        # Reuse the same name then
+        return '%s.%s'%(os.path.splitext(opts['analyze'].split(',')[0])\
+                                                                  [0],extension)
+    # if a name is specified, use it
+    if opts['name']!='auto':
+        basename = opts['name']
+    else:
+        prefix = 'cms_check_'
+        # Use process name if there is only one process            
+        if len(cms_res['ordered_processes'])==1:
+            proc = cms_res['ordered_processes'][0]
+            replacements = {' ':'','+':'p','-':'m','~':'x', '>':'_','=':'eq'}
+            # Remove the perturbation couplings:
+            try:
+                proc=proc[:proc.index('[')]
+            except ValueError:
+                pass
+    
+            for key, value in replacements.items():
+                proc = proc.replace(key,value)
+    
+            basename =prefix+proc+'_%s_'%used_model.get('name')+\
+                      ( ('_'+'_'.join(cms_res['perturbation_orders'])) if \
+                                      cms_res['perturbation_orders']!=[] else '')
+        # Use timestamp otherwise
+        else:
+            basename = prefix+datetime.datetime.now().strftime("%Y_%m_%d_%Hh%Mm%Ss")
+            
+    suffix = '_%s'%opts['tweak']['name'] if opts['tweak']['name']!='' else '' 
+    if output_path:     
+        return pjoin(output_path,'%s%s.%s'%(basename,suffix,extension))
+    else:
+        return '%s%s.%s'%(basename,suffix,extension)
+
+def output_complex_mass_scheme(result,output_path, options, model, output='text'):
+    """ Outputs nicely the outcome of the complex mass scheme check performed
+    by varying the width in the offshell region of resonances found for eahc process.
+    Output just specifies whether text should be returned or a list of failed
+    processes."""
+    
+    pert_orders=result['perturbation_orders']
+    
+    ######## CHECK PARAMETERS #########
+    #
+    # diff_lambda_power choses the power by which one should divide the difference
+    # curve. The test should only work with 1, but it is useful for the LO
+    # check to see the difference has O(\lambda) contribution by setting this
+    # parameter to 2. If the Born does not have O(\lambda) contributions
+    # (i.e. if the test still pas with diff_lambda_power=2) then the NLO test
+    # will not be sensitive to the CMS implementation details.
+    diff_lambda_power = options['diff_lambda_power']
+    # DISLAIMER:
+    # The CMS check is non trivial to automate and it is actually best done
+    # manually by looking at plots for various implementation of the CMS.
+    # The automatic check performed here with the default parameters below
+    # should typically capture the main features of the CMS implementation.
+    # There will always be exceptions however.
+    #
+    if 'has_FRdecay' in result:
+        has_FRdecay = result['has_FRdecay']
+    else:
+        has_FRdecay = False
+    # be tighter at LO
+    if not pert_orders:
+        CMS_test_threshold = 1e-3
+    else:
+        # AT NLO, a correct cancellation is typically of the order of 2% with
+        # a lowest lambda value of 10^-4. It is clear that the threshold should
+        # scale with the minimum lambda value because any little offset in the
+        # LO width value for example (acceptable when less than one 1% if the
+        # widths were computed numerically) will lead to an inaccuracy of the 
+        # cancellation scaling with lambda. 
+        if not has_FRdecay and ('recomputed_with' not in result or \
+                          result['recompute_width'] in ['always','first_time']):
+            CMS_test_threshold = 2e-2*(1.0e-4/min(result['lambdaCMS']))
+        else:
+            # If the widths were not computed numerically, then the accuracy of
+            # the cancellation should be better.
+            CMS_test_threshold = 2e-2*(1.0e-5/min(result['lambdaCMS']))
+            
+    # This threshold sets how flat the diff line must be when approaching it from
+    # the right to start considering its value. Notice that it cannot be larger
+    # than the CMS_test_threshold
+    consideration_threshold = min(CMS_test_threshold/10.0, 0.05)
+    # Number of values groupes with the median technique to avoid being
+    # sensitive to unstabilities
+    group_val = 3
+    # Starting from which value, relative to the averaged diff, should one consider
+    # the asymptotic diff median to be exactly 0.0 in which case one would use this
+    # average instead of this asymptotic median. u d~ > e+ ve LO exhibit a \
+    # difference at zero for example.
+    diff_zero_threshold = 1e-3
+    # Plotting parameters. Specify the lambda range to plot. 
+    # lambda_range = [-1,-1] returns the default automatic setup
+    lambda_range = options['lambda_plot_range']
+    ##################################
+    
+#   One can print out the raw results by uncommenting the line below
+#    misc.sprint(result)
+#    for i, res in enumerate(result['a e- > e- ve ve~ [ virt = QCD QED ]']['CMS']):
+#    for i, res in enumerate(result['u d~ > e+ ve a [ virt = QCD QED ]']['CMS']):
+#        if res['resonance']['FSMothersNumbers'] == set([3, 4]):
+#            misc.sprint(res['resonance']['PS_point_used'])
+#    stop
+    
+    res_str = ''
+    
+    ####### BEGIN helper functions
+
+    # Chose here whether to use Latex particle names or not
+    # Possible values are 'none', 'model' or 'built-in'
+    useLatexParticleName = 'built-in'
+    name2tex = {'e+':r'e^+','w+':r'W^+','a':r'\gamma','g':'g',
+                'e-':r'e^-','w-':r'W^-','z':'Z','h':'H',
+                'mu+':r'\mu^+',
+                'mu-':r'\mu^-',
+                'ta+':r'\tau^+',
+                'ta-':r'\tau^-'}
+    for p in ['e','m','t']:
+        d = {'e':'e','m':r'\mu','t':r'\tau'}
+        name2tex['v%s'%p]=r'\nu_{%s}'%d[p]
+        name2tex['v%s~'%p]=r'\bar{\nu_{%s}}'%d[p]
+        
+    for p in ['u','d','c','s','b','t']:
+        name2tex[p]=p
+        name2tex['%s~'%p]=r'\bar{%s}'%p
+      
+    def format_particle_name(particle, latex=useLatexParticleName):
+        p_name = particle
+        if latex=='model':
+            try:
+                texname = model.get_particle(particle).get('texname')
+                if texname and texname!='none':
+                    p_name = r'$\displaystyle %s$'%texname
+            except:
+                pass
+        elif latex=='built-in':
+            try:
+                p_name = r'$\displaystyle %s$'%name2tex[particle]
+            except:
+                pass
+        return p_name
+
+    def resonance_str(resonance, latex=useLatexParticleName):
+        """ Provides a concise string to characterize the resonance """
+        particle_name = model.get_particle(resonance['ParticlePDG']).get_name()
+        mothersID=['%d'%n for n in sorted(resonance['FSMothersNumbers'])]
+        return r"%s [%s]"%(format_particle_name(particle_name,latex=latex),
+                                                            ','.join(mothersID))
+
+    def format_title(process, resonance):
+        """ Format the plot title given the process and resonance """
+        
+        process_string = []
+        for particle in process.split():
+            if particle=='$$':
+                process_string.append(r'\$\$')
+                continue
+            if particle=='>':
+                process_string.append(r'$\displaystyle \rightarrow$')
+                continue
+            process_string.append(format_particle_name(particle))              
+
+        if resonance=='':
+            return r'CMS check for %s' %(' '.join(process_string))
+        else:
+            return r'CMS check for %s ( resonance %s )'\
+                                           %(' '.join(process_string),resonance)
+
+    def guess_lambdaorder(ME_values_list, lambda_values, expected=None,
+                                                           proc=None, res=None):
+        """ Guess the lambda scaling from a list of ME values and return it.
+        Also compare with the expected result if specified and trigger a 
+        warning if not in agreement."""
+        # guess the lambdaCMS power in the amplitude squared
+        bpowers = []
+        for i, lambdaCMS in enumerate(lambda_values[1:]):
+            bpowers.append(round(math.log(ME_values_list[0]/ME_values_list[i+1],\
+                                                   lambda_values[0]/lambdaCMS)))
+
+        # Pick the most representative power
+        bpower = sorted([(el, bpowers.count(el)) for el in set(bpowers)],
+                                 key = lambda elem: elem[1], reverse=True)[0][0]
+        if not expected:
+            return bpower
+        if bpower != expected:
+            logger.warning('The apparent scaling of the squared amplitude'+
+             'seems inconsistent w.r.t to detected value '+
+             '(%i vs %i). %i will be used.'%(expected,bpower,bpower)+
+             ' This happend for process %s and resonance %s'%(proc, res))
+        return bpower    
+
+    def check_stability(ME_values, lambda_values, lambda_scaling, values_name):
+        """ Checks if the values passed in argument are stable and return the 
+        stability check outcome warning if it is not precise enough. """
+        values = sorted([
+            abs(val*(lambda_values[0]/lambda_values[i])**lambda_scaling) for \
+                                                i, val in enumerate(ME_values)])
+        median = values[len(values)//2]
+        max_diff = max(abs(values[0]-median),abs(values[-1]-median))
+        stability = max_diff/median
+        stab_threshold = 1e-2
+        if stability >= stab_threshold:
+            return "== WARNING: Stability check failed for '%s' with stability %.2e.\n"\
+                                                       %(values_name, stability)
+        else:
+            return None
+    ####### END helper functions
+    if options['analyze']=='None':
+        if options['reuse']:
+            save_path = CMS_save_path('pkl', result, model, options, 
+                                                        output_path=output_path)
+            res_str += "\nThe results of this check have been stored on disk and its "+\
+              "analysis can be rerun at anytime with the MG5aMC command:\n   "+\
+            "      check cms --analyze=%s\n"%save_path
+            save_load_object.save_to_file(save_path, result)
+        elif len(result['ordered_processes'])>0:
+            res_str += "\nUse the following synthax if you want to store "+\
+                    "the raw results on disk.\n"+\
+                    "    check cms -reuse <proc_def> <options>\n"
+    
+    ############################
+    # Numerical check first    #
+    ############################
+    
+    checks = []
+    for process in result['ordered_processes']:
+        checks.extend([(process,resID) for resID in \
+                                            range(len(result[process]['CMS']))])
+        
+    if options['reuse']:
+        logFile = open(CMS_save_path(
+                    'log', result, model, options, output_path=output_path),'w')
+    
+    lambdaCMS_list=result['lambdaCMS']
+    
+    # List of failed processes
+    failed_procs = []
+
+    # A bar printing function helper. Change the length here for esthetics
+    bar = lambda char: char*47
+
+    # Write out the widths used if information is present:
+    if 'widths_computed' in result:
+        res_str += '\n%s%s%s\n'%(bar('='),' Widths ',bar('='))
+        if result['recompute_width'] == 'never':
+            res_str += '| Widths extracted from the param_card.dat'
+        else:
+            res_str += '| Widths computed %s'%('analytically' if has_FRdecay 
+                                                             else 'numerically')
+            if result['recompute_width'] == 'first_time':
+                res_str += ' for \lambda = 1'
+            elif result['recompute_width'] == 'always':
+                res_str += ' for all \lambda values'
+        res_str += " using mode '--recompute_width=%s'.\n"%result['recompute_width']
+        for particle_name, width in result['widths_computed']:
+            res_str += '| %-10s = %-11.6gGeV\n'%('Width(%s)'%particle_name,width)
+        res_str += '%s%s%s\n'%(bar('='),'='*8,bar('='))
+
+    # Doing the analysis to printout to the MG5 interface and determine whether
+    # the test is passed or not
+    # Number of last points to consider for the stability test
+    nstab_points=group_val
+    # Store here the asymptot detected for each difference curve
+    differences_target = {}
+    for process, resID in checks:
+        proc_res = result[process]
+        cms_res = proc_res['CMS'][resID]
+        nwa_res = proc_res['NWA'][resID]
+        resonance = resonance_str(cms_res['resonance'], latex='none')
+        cms_born=cms_res['born']
+        nwa_born=nwa_res['born']
+        # Starting top thick bar
+        res_str += '\n%s%s%s\n'%(bar('='),'='*8,bar('='))
+        # Centered process and resonance title
+        proc_title = "%s (resonance %s)"%(process,resonance)
+        centering = (bar(2)+8-len(proc_title))//2
+        res_str += "%s%s\n"%(' '*centering,proc_title)
+        # Starting bottom thin bar
+        res_str += '%s%s%s\n'%(bar('-'),'-'*8,bar('-'))
+        # Reminder if diff_lambda_power is not 1
+        
+        if diff_lambda_power!=1:
+            res_str += "== WARNING diff_lambda_power is not 1 but    = %g\n"%diff_lambda_power
+            res_str += '%s%s%s\n'%(bar('-'),'-'*8,bar('-'))
+
+        born_power = guess_lambdaorder(nwa_born,lambdaCMS_list,
+               expected=proc_res['born_order'], proc=process, res=resonance)
+        stab_cms_born = check_stability(cms_born[-nstab_points:], 
+                         lambdaCMS_list[-nstab_points:], born_power, 'CMS Born')
+        if stab_cms_born:
+            res_str += stab_cms_born
+        stab_nwa_born = check_stability(nwa_born[-nstab_points:], 
+                         lambdaCMS_list[-nstab_points:], born_power, 'NWA Born')
+        if stab_nwa_born:
+            res_str += stab_nwa_born
+        # Write out the phase-space point
+        res_str += "== Kinematic configuration in GeV (E,px,pypz)\n"
+        for i, p in enumerate(cms_res['resonance']['PS_point_used']):
+            res_str += "  | p%-2.d = "%(i+1)
+            for pi in p:
+                res_str += '%-24.17g'%pi if pi<0.0 else ' %-23.17g'%pi 
+            res_str += "\n"
+        # Write out the offshellnesses specification
+        res_str += "== Offshellnesses of all detected resonances\n"
+        for res_name, offshellness in cms_res['resonance']['offshellnesses']:
+            res_str += "  | %-15s = %f\n"%(res_name, offshellness)
+        res_str += '%s%s%s\n'%(bar('-'),'-'*8,bar('-'))
+
+        if not pert_orders:
+            res_str += "== Born scaling lambda^n_born. nborn         = %d\n"%born_power
+        else:
+            cms_finite=cms_res['finite']
+            nwa_finite=nwa_res['finite']
+            loop_power = guess_lambdaorder(nwa_finite,lambdaCMS_list,
+                   expected=proc_res['loop_order'], proc=process, res=resonance)  
+            res_str += "== Scaling lambda^n. nborn, nloop            = %d, %d\n"\
+                                                        %(born_power,loop_power)
+            stab_cms_finite = check_stability(cms_finite[-nstab_points:], 
+                                  lambdaCMS_list[-nstab_points:], loop_power, 'CMS finite')
+            if stab_cms_finite:
+                res_str += stab_cms_finite
+            stab_nwa_finite = check_stability(nwa_finite[-nstab_points:], 
+                      lambdaCMS_list[-nstab_points:], loop_power, 'NWA finite')
+            if stab_nwa_finite:
+                res_str += stab_nwa_finite
+        # Now organize data
+        CMSData     = []
+        NWAData     = []
+        DiffData    = []
+        for idata, lam in enumerate(lambdaCMS_list):
+            if not pert_orders:
+                new_cms=cms_born[idata]/(lam**born_power)
+                new_nwa=nwa_born[idata]/(lam**born_power)
+            else:
+                new_cms=(cms_finite[idata]+cms_born[idata]-nwa_born[idata])/(lam*nwa_born[idata])
+                new_nwa=nwa_finite[idata]/(lam*nwa_born[idata])
+            new_diff=(new_cms-new_nwa)/(lam**diff_lambda_power)
+            CMSData.append(new_cms)
+            NWAData.append(new_nwa)
+            DiffData.append(new_diff)
+
+                    
+        # NWA Born median
+
+        # Find which values to start the test at by looking at the CMSdata scaling
+        # First compute the median of the middle 60% of entries in the plot
+        trim_range=int(((1.0-0.6)/2.0)*len(DiffData))
+        low_diff_median = sorted(DiffData[trim_range:-trim_range])\
+                                               [(len(DiffData)-2*trim_range)//2]
+        
+        # Now walk the values from the right of the diff plot until we reaches
+        # values stable with respect to the CMS_tale_median. This value will
+        # be limit of the range considered for the CMS test. Do it in a way which
+        # is insensitive to instabilities, by considering medians of group_val 
+        # consecutive points.
+        current_median = 0
+        # We really want to select only the very stable region
+        scan_index = 0
+        reference = abs(sorted(NWAData)[len(NWAData)//2])
+        if low_diff_median!= 0.0:
+            if abs(reference/low_diff_median)<diff_zero_threshold:
+                reference = abs(low_diff_median)
+        while True:
+            scanner = DiffData[scan_index:group_val+scan_index]
+            current_median = sorted(scanner)[len(scanner)//2]
+            # Useful for debugging
+            #misc.sprint(scanner,current_median,abs(current_median-low_diff_median)/reference,reference,consideration_threshold)
+            if abs(current_median-low_diff_median)/reference<\
+                                                        consideration_threshold:
+                break;
+            scan_index += 1
+            if (group_val+scan_index)>=len(DiffData):
+                # this should not happen, but in this case we arbitrarily take
+                # half of the data
+                logger.warning('The median scanning failed during the CMS check '+
+                  'for process %s'%proc_title+\
+                  'This is means that the difference plot has not stable'+\
+                  'intermediate region and MG5_aMC will arbitrarily consider the'+\
+                                                     'left half of the values.')
+                scan_index = -1
+                break;
+        
+        if scan_index == -1:
+            cms_check_data_range = len(DiffData)//2
+        else:
+            cms_check_data_range = scan_index + group_val
+
+        res_str += "== Data range considered (min, max, n_val)   = (%.1e, %.1e, %d)\n"\
+                  %(lambdaCMS_list[-1],lambdaCMS_list[scan_index],
+                                                 len(lambdaCMS_list)-scan_index)
+        # Now setup the list of values affecting the CMScheck
+        CMScheck_values = DiffData[cms_check_data_range:]
+
+        # For the purpose of checking the stability of the tale, we now do
+        # the consideration_threshold scan from the *left* and if we finsih
+        # before the end, it means that there is an unstable region.
+        if scan_index >= 0:            
+            # try to find the numerical instability region
+            scan_index = len(CMScheck_values)
+            used_group_val = max(3,group_val)
+            unstability_found = True
+            while True:
+                scanner = CMScheck_values[scan_index-used_group_val:scan_index]
+                maxdiff =  max(abs(scan-low_diff_median) for scan in scanner)
+                if maxdiff/reference<consideration_threshold:
+                    break;
+                if (scan_index-used_group_val)==0:
+                    # this only happens when no stable intermediate region can be found
+                    # Set scan_index to -99 so as to prevent warning
+                    unstability_found = False
+                    break;
+                # Proceed to th next block of data
+                scan_index -= 1
+
+            # Now report here the unstability found
+            if unstability_found:
+                unstab_check=CMScheck_values[scan_index:]
+                relative_array = [val > CMScheck_values[scan_index-1] for 
+                                                            val in unstab_check]
+                upper = relative_array.count(True)
+                lower = relative_array.count(False)
+                if not ((lower==0 and upper>=0) or (lower>=0 and upper==0)):
+                    logger.warning(
+"""For process %s, a numerically unstable region was detected starting from lambda < %.1e.
+Look at the plot in this region (and possibly throw more points using the option --lambdaCMS).
+If this is indeed a stability issue, then either decrease MLStabThreshold in MadLoop or decrease the
+minimum value of lambda to be considered in the CMS check."""\
+                %(proc_title, lambdaCMS_list[cms_check_data_range+scan_index-1]))
+        
+        # Now apply the same same technique, as above but to the difference plot
+        # Now we will use low_diff_median instead of diff_tale_median
+        #diff_tale_median = sorted(CMScheck_values)[len(CMScheck_values)//2]
+        scan_index = 0
+        max_diff = 0.0
+        res_str += "== Ref. value used in the ratios (Born NWA)  = %s\n"\
+                                                             %('%.3g'%reference)
+        res_str += "== Asymptotic difference value detected      = %s\n"\
+                                                       %('%.3g'%low_diff_median)
+        # Pass information to the plotter for the difference target
+        differences_target[(process,resID)]= low_diff_median
+#        misc.sprint('Now doing resonance %s.'%res_str)
+        while True:
+            current_vals = CMScheck_values[scan_index:scan_index+group_val]      
+            max_diff = max(max_diff, abs(low_diff_median-
+                     sorted(current_vals)[len(current_vals)//2])/reference)
+            if (scan_index+group_val)>=len(CMScheck_values):
+                break
+            scan_index += 1
+        
+        # Now use the CMS check result
+        res_str += "== CMS check result (threshold)              = "+\
+                   "%.3g%% (%s%.3g%%)\n"%(max_diff*100.0, 
+                     '>' if max_diff>CMS_test_threshold else '<',
+                                                       CMS_test_threshold*100.0)
+        if max_diff>CMS_test_threshold:
+            failed_procs.append((process,resonance))
+        res_str += "%s %s %s\n"%(bar('='),
+                 'FAILED' if max_diff>CMS_test_threshold else 'PASSED',bar('='))
+
+    if len(checks):
+        res_str += "\nSummary: %i/%i passed"%(len(checks)-len(failed_procs),len(checks))+\
+                    ('.\n' if not failed_procs else ', failed checks are for:\n')
+    else:
+        res_str += "\nNo CMS check to perform."
+        
+    for process, resonance in failed_procs:
+        res_str += ">  %s, %s\n"%(process, resonance)
+
+    ############################
+    # Now we turn to the plots #
+    ############################
+    if not options['show_plot']:
+        if options['reuse']:
+            logFile.write(res_str)
+            logFile.close()
+        if output=='text':
+            return res_str
+        else:
+            return failed_procs
+        
+    fig_output_file = CMS_save_path('pdf', result, model, options, 
+                                                        output_path=output_path)
+    base_fig_name = fig_output_file[:-4]
+    suffix = 1
+    while os.path.isfile(fig_output_file):
+        fig_output_file = '%s__%d__.pdf'%(base_fig_name,suffix)
+        suffix+=1
+
+    process_data_plot_dict={}
+    
+    # load possible additional results. The second element of the tuple is
+    # the dataset name.
+    all_res = [(result, None)]
+    for i, add_res in enumerate(options['analyze'].split(',')[1:]):
+        specs =re.match(r'^(?P<filename>.*)\((?P<title>.*)\)$', add_res)
+        if specs:
+            filename = specs.group('filename')
+            title    = specs.group('title')
+        else:
+            filename = add_res
+            title    = '#%d'%(i+1)
+
+        new_result = save_load_object.load_from_file(filename)
+        if new_result is None:
+            raise InvalidCmd('The complex mass scheme check result'+
+                             " file below could not be read.\n     %s"%filename)
+        if len(new_result['ordered_processes'])!=len(result['ordered_processes']) \
+                      or len(new_result['lambdaCMS'])!=len(result['lambdaCMS']):
+            raise self.InvalidCmd('The complex mass scheme check result'+
+                      " file below does not seem compatible.\n     %s"%filename)
+        all_res.append((new_result,title))
+    
+    # Prepare the data
+    for process, resID in checks:
+        data1=[] # for subplot 1,i.e. CMS and NWA
+        data2=[] # for subplot 2,i.e. diff
+        info ={} # info to be passed to the plotter
+        for res in all_res:
+            proc_res = res[0][process]
+            cms_res = proc_res['CMS'][resID]
+            nwa_res = proc_res['NWA'][resID]
+            resonance = resonance_str(cms_res['resonance'])
+            if options['resonances']!=1:
+                info['title'] = format_title(process, resonance)
+            else:
+                info['title'] = format_title(process, '')
+            # Born result
+            cms_born=cms_res['born']
+            nwa_born=nwa_res['born']
+            if len(cms_born) != len(lambdaCMS_list) or\
+                 len(nwa_born) != len(lambdaCMS_list):
+                raise MadGraph5Error, 'Inconsistent list of results w.r.t. the'+\
+                                ' lambdaCMS values specified for process %s'%process
+            if pert_orders:
+                cms_finite=cms_res['finite'] 
+                nwa_finite=nwa_res['finite']
+                if len(cms_finite) != len(lambdaCMS_list) or\
+                    len(nwa_finite) != len(lambdaCMS_list):
+                    raise MadGraph5Error, 'Inconsistent list of results w.r.t. the'+\
+                                ' lambdaCMS values specified for process %s'%process
+        
+            bpower = guess_lambdaorder(nwa_born,lambdaCMS_list,
+                    expected=proc_res['born_order'], proc=process, res=resonance)
+
+            CMSData  = []
+            NWAData  = []
+            DiffData = []   
+            for idata, lam in enumerate(lambdaCMS_list):
+                if not pert_orders:
+                    new_cms = cms_born[idata]/lam**bpower
+                    new_nwa = nwa_born[idata]/lam**bpower
+                else:
+                    new_cms=cms_finite[idata]+cms_born[idata]-nwa_born[idata]
+                    new_nwa=nwa_finite[idata]
+                    new_cms /= lam*nwa_born[idata]
+                    new_nwa /= lam*nwa_born[idata]
+                new_diff=(new_cms-new_nwa)/(lam**diff_lambda_power)
+                CMSData.append(new_cms)
+                NWAData.append(new_nwa)
+                DiffData.append(new_diff)
+            if res[1] is None:
+                if not pert_orders:
+                    data1.append([r'$\displaystyle CMS\;=\;\mathcal{M}_{CMS}^{(0)}/\lambda^%d$'%bpower,CMSData])
+                    data1.append([r'$\displaystyle NWA\;=\;\mathcal{M}_{NWA}^{(0)}/\lambda^%d$'%bpower,NWAData])
+                else:
+                    data1.append([r'$\displaystyle CMS\;=\;(\mathcal{M}^{(1)}_{CMS}+\mathcal{M}_{CMS}^{(0)}-\mathcal{M}^{(0)}_{NWA})/(\lambda\cdot\mathcal{M}^{(0)}_{NWA})$',CMSData])
+                    data1.append([r'$\displaystyle NWA\;=\;\mathcal{M}^{(1)}_{NWA}/(\lambda\cdot\mathcal{M}^{(0)}_{NWA})$',NWAData])
+                data2.append([r'$\displaystyle\Delta\;=\;(CMS-NWA)/\lambda%s$'\
+                    %('' if diff_lambda_power==1 else r'^{%g}'%diff_lambda_power)
+                                                                     ,DiffData])
+                data2.append([r'Detected asymptot',[differences_target[(process,resID)] 
+                                                for i in range(len(lambdaCMS_list))]])
+            else:
+                data1.append([r'$\displaystyle CMS$  %s'%res[1].replace('_',' '),CMSData])
+                data1.append([r'$\displaystyle NWA$  %s'%res[1].replace('_',' '),NWAData])
+                data2.append([r'$\displaystyle\Delta$  %s'%res[1].replace('_',' '),DiffData])
+                
+        process_data_plot_dict[(process,resID)]=(data1,data2, info)
+
+    # Now turn to the actual plotting
+    try:
+        import matplotlib.pyplot as plt
+        from matplotlib.backends.backend_pdf import PdfPages
+
+        # output the figures
+        if lambda_range[1]>0:
+            min_lambda_index = -1
+            for i, lam in enumerate(lambdaCMS_list):
+                if lam<=lambda_range[1]:
+                    min_lambda_index = i
+                    break
+        else:
+            min_lambda_index = 0
+        if lambda_range[0]>0:
+            max_lambda_index = -1
+            for i, lam in enumerate(lambdaCMS_list):
+                if lam<=lambda_range[0]:
+                    max_lambda_index=i-1
+                    break
+        else:
+            max_lambda_index=len(lambdaCMS_list)-1
+    
+        if max_lambda_index==-1 or min_lambda_index==-1 or \
+                                             min_lambda_index==max_lambda_index:
+            raise InvalidCmd('Invalid lambda plotting range: (%.1e,%.1e)'%\
+                                              (lambda_range[0],lambda_range[1]))
+        # Trim lambda values
+        if lambda_range[0]>0.0 or lambda_range[1]>0.0:
+            lambdaCMS_list = lambdaCMS_list[min_lambda_index:max_lambda_index+1]
+
+        plt.rc('text', usetex=True)
+        plt.rc('font', family='serif')
+        pp=PdfPages(fig_output_file)
+        if len(checks)==0 or len(process_data_plot_dict[checks[0]][1])<=7:
+            colorlist=['b','r','g','k','c','m','y']
+        else:
+            import matplotlib.colors as colors
+            import matplotlib.cm as mplcm
+            import matplotlib.colors as colors
+            
+            # Nice color maps here are 'gist_rainbow'
+            cm = plt.get_cmap('gist_rainbow')
+            cNorm  = colors.Normalize(vmin=0, vmax=(len(data2)-1))
+            scalarMap = mplcm.ScalarMappable(norm=cNorm, cmap=cm)
+            # use vmax=(len(data1)-1)*0.9 to remove pink at the end of the spectrum
+            colorlist = [scalarMap.to_rgba(i*0.9) for i in range(len(data2))]
+            # Or it is also possible to alternate colors so as to make them 
+            # as distant as possible to one another
+            # colorlist = sum([
+            #    [scalarMap.to_rgba(i),scalarMap.to_rgba(i+len(data2)//2)]
+            #                                  for i in range(len(data2)//2)],[])
+
+        legend_size = 10
+        for iproc, (process, resID) in enumerate(checks):
+            data1,data2, info=process_data_plot_dict[(process,resID)]
+            # Trim dataplot if necessary
+            if lambda_range[0]>0.0 or lambda_range[1]>0.0:
+                for i in range(len(data1)):
+                    data1[i][1]=data1[i][1][min_lambda_index:max_lambda_index+1]
+                for i in range(len(data2)):
+                    data2[i][1]=data2[i][1][min_lambda_index:max_lambda_index+1]
+            plt.figure(iproc+1)
+            plt.subplot(211)
+            minvalue=1e+99
+            maxvalue=-1e+99
+            for i, d1 in enumerate(data1):
+                # Use the same color for NWA and CMS curve but different linestyle
+                color=colorlist[i//2]
+                data_plot=d1[1]
+                minvalue=min(min(data_plot),minvalue)
+                maxvalue=max(max(data_plot),maxvalue)           
+                plt.plot(lambdaCMS_list, data_plot, color=color, marker='', \
+                        linestyle=('-' if i%2==0 else '--'), 
+                        label=(d1[0] if (i%2==0 or i==1) else '_nolegend_'))
+            ymin = minvalue-(maxvalue-minvalue)/5.
+            ymax = maxvalue+(maxvalue-minvalue)/5.
+
+            plt.yscale('linear')
+            plt.xscale('log')
+            plt.title(info['title'],fontsize=12,y=1.08)
+            plt.ylabel(r'$\displaystyle \mathcal{M}$')
+            #plt.xlabel('lambdaCMS')
+            if ymax*len(data1)-sum(max(d1[1][-len(d1[1])//2:]) \
+                                 for d1 in data1) > 0.5*(ymax-ymin)*len(data1):
+                plt.legend(prop={'size':legend_size},loc='upper left', frameon=False)
+            else:
+                plt.legend(prop={'size':legend_size},loc='lower left', frameon=False)
+                
+            plt.axis([min(lambdaCMS_list),max(lambdaCMS_list), ymin, ymax])
+            
+            plt.subplot(212)
+            minvalue=1e+99
+            maxvalue=-1e+99
+            
+            try:
+                asymptot_index = [d2[0] for d2 in data2].index('Detected asymptot')
+                plt.plot(lambdaCMS_list, data2[asymptot_index][1], 
+                               color='0.75', marker='', linestyle='-', label='')
+            except ValueError:
+                pass
+            
+            color_ID = -1
+            for d2 in data2:
+                # Special setup for the reference asymptot straight line
+                if d2[0]=='Detected asymptot':
+                    continue
+                color_ID += 1
+                color=colorlist[color_ID]
+                data_plot=d2[1]
+                minvalue=min(min(data_plot),minvalue)
+                maxvalue=max(max(data_plot),maxvalue)
+                plt.plot(lambdaCMS_list, data_plot, color=color, marker='',\
+                                                     linestyle='-', label=d2[0])
+            ymin = minvalue-(maxvalue-minvalue)/5.
+            ymax = maxvalue+(maxvalue-minvalue)/5.
+
+            plt.yscale('linear')
+            plt.xscale('log')
+            plt.ylabel(r'$\displaystyle \Delta$')
+            plt.xlabel(r'$\displaystyle \lambda$')
+            # The unreadable stuff below is just to check if the left of the 
+            # plot is stable or not
+            sd = [sorted(d2[1][-len(d2[1])//2:]) for d2 in data2]
+            left_stability = sum(abs(s[0]-s[-1]) for s in sd)
+            sd = [sorted(d2[1][:-len(d2[1])//2]) for d2 in data2]
+            right_stability = sum(abs(s[0]-s[-1]) for s in sd)
+            left_stable =  False if right_stability==0.0 else \
+                                            (left_stability/right_stability)<0.1
+ 
+            if left_stable:
+                if ymax*len(data2)-sum(max(d2[1][-len(d2[1])//2:]) \
+                                 for d2 in data2) > 0.5*(ymax-ymin)*len(data2):
+                    plt.legend(prop={'size':legend_size},loc='upper left', frameon=False)
+                else:
+                    plt.legend(prop={'size':legend_size},loc='lower left', frameon=False)                
+            else:
+                if ymax*len(data2)-sum(max(d2[1][:-len(d2[1])//2]) \
+                                  for d2 in data2) > 0.5*(ymax-ymin)*len(data2):
+                    plt.legend(prop={'size':legend_size},loc='upper right', frameon=False)
+                else:
+                    plt.legend(prop={'size':legend_size},loc='lower right', frameon=False)
+
+            plt.axis([min(lambdaCMS_list),max(lambdaCMS_list),\
+              minvalue-(maxvalue-minvalue)/5., maxvalue+(maxvalue-minvalue)/5.])
+            
+            plt.savefig(pp,format='pdf')
+
+        pp.close()
+        
+        if len(checks)>0:
+            logger.info('Some cms check statistics will be displayed once you '+\
+                            'close the plot window')
+            logger.info('Complex Mass Scheme check plot output to file %s. '%fig_output_file)
+            
+            if sys.platform.startswith('linux'):
+                misc.call(["xdg-open", fig_output_file])
+            elif sys.platform.startswith('darwin'):
+                misc.call(["open", fig_output_file])
+        
+        plt.close("all")
+    
+    except IOError as e:
+        if isinstance(e, ImportError):
+            res_str += "\n= Install matplotlib to get a "+\
+                "graphical display of the results of the cms check."
+        else:
+            res_str += "\n= Could not produce the cms check plot because of "+\
+                                                "the following error: %s"%str(e)
+    
+    if options['reuse']:
+        logFile.write(res_str)
+        logFile.close()
+
+    if output=='text':
+        return res_str
+    else:
+        return failed_procs

=== modified file 'models/check_param_card.py'
--- models/check_param_card.py	2015-07-16 11:03:56 +0000
+++ models/check_param_card.py	2015-08-16 06:06:34 +0000
@@ -13,6 +13,8 @@
 except:
     import internal.file_writers as file_writers
     import internal.misc as misc
+
+import StringIO
     
 class InvalidParamCard(Exception):
     """ a class for invalid param_card """
@@ -274,9 +276,8 @@
         self.order = []
         
         if isinstance(input_path, ParamCard):
-            self.order = list(input_path.order)
-            self.update(input_path)
-            self.input_path = input_path.input_path 
+            self.read(StringIO.StringIO(input_path.write())) 
+            self.input_path = input_path.input_path
         else:
             self.input_path = input_path
             if input_path:
@@ -342,7 +343,7 @@
                   
         return self
     
-    def write(self, outpath):
+    def write(self, outpath=None):
         """schedular for writing a card"""
   
         # order the block in a smart way
@@ -372,10 +373,8 @@
                     diff += 'set param_card %s %s %s # orig: %s\n' % \
                                        (blockname, lhacode , new_value, value)
         return diff 
-                
-        
-    
-            
+
+
     def write_inc_file(self, outpath, identpath, default, need_mp=False):
         """ write a fortran file which hardcode the param value"""
         
@@ -396,8 +395,7 @@
                 except KeyError:
                     value =defaultcard[block].get(tuple(lhaid)).value
                     logger.warning('information about \"%s %s" is missing using default value: %s.' %\
-                                   (block, lhaid, value))
-
+                                                          (block, lhaid, value))
             else:
                 value =defaultcard[block].get(tuple(lhaid)).value
                 logger.warning('information about \"%s %s" is missing (full block missing) using default value: %s.' %\
@@ -406,7 +404,61 @@
             fout.writelines(' %s = %s' % (variable, str(value).replace('e','d')))
             if need_mp:
                 fout.writelines(' mp__%s = %s_16' % (variable, value))
-                
+      
+    def convert_to_complex_mass_scheme(self):
+        """ Convert this param_card to the convention used for the complex mass scheme:
+        This includes, removing the Yukawa block if present and making sure the EW input
+        scheme is (MZ, MW, aewm1). """
+        
+        # The yukawa block is irrelevant for the CMS models, we must remove them
+        if self.has_block('yukawa'):
+            # Notice that the last parameter removed will also remove the block.
+            for lhacode in [param.lhacode for param in self['yukawa']]:
+                self.remove_param('yukawa', lhacode)
+    
+        # Now fix the EW input scheme
+        EW_input = {('sminputs',(1,)):None,
+                    ('sminputs',(2,)):None,
+                    ('mass',(23,)):None,
+                    ('mass',(24,)):None}
+        for block, lhaid in EW_input.keys():
+            try:
+                EW_input[(block,lhaid)] = self[block].get(lhaid).value
+            except:
+                pass
+            
+        # Now specify the missing values. We only support the following EW
+        # input scheme:
+        # (alpha, GF, MZ) input
+        internal_param = [key for key,value in EW_input.items() if value is None]
+        if len(internal_param)==0:
+            # All parameters are already set, no need for modifications
+            return
+        
+        if len(internal_param)!=1:
+            raise InvalidParamCard,' The specified EW inputs has more than one'+\
+                ' unknown: [%s]'%(','.join([str(elem) for elem in internal_param]))
+        
+        
+        if not internal_param[0] in [('mass',(24,)), ('sminputs',(2,)),
+                                                             ('sminputs',(1,))]:
+            raise InvalidParamCard, ' The only EW input scheme currently supported'+\
+                        ' are those with either the W mass or GF left internal.'
+        
+        # Now if the Wmass is internal, then we must change the scheme
+        if internal_param[0] == ('mass',(24,)):
+            aewm1 = EW_input[('sminputs',(1,))]
+            Gf    = EW_input[('sminputs',(2,))]
+            Mz    = EW_input[('mass',(23,))]
+            try:
+                Mw = math.sqrt((Mz**2/2.0)+math.sqrt((Mz**4/4.0)-((
+                              (1.0/aewm1)*math.pi*Mz**2)/(Gf*math.sqrt(2.0)))))
+            except:
+                InvalidParamCard, 'The EW inputs 1/a_ew=%f, Gf=%f, Mz=%f are inconsistent'%\
+                                                                   (aewm1,Gf,Mz)
+            self.remove_param('sminputs', (2,))
+            self.add_param('mass', (24,), Mw, 'MW')
+        
     def append(self, obj):
         """add an object to this"""
         

=== modified file 'models/import_ufo.py'
--- models/import_ufo.py	2015-08-07 00:15:39 +0000
+++ models/import_ufo.py	2015-08-16 06:06:34 +0000
@@ -75,7 +75,8 @@
 
     return model_path
 
-def import_model(model_name, decay=False, restrict=True, prefix='mdl_'):
+def import_model(model_name, decay=False, restrict=True, prefix='mdl_',
+                                                    complex_mass_scheme = None):
     """ a practical and efficient way to import a model"""
     
     # check if this is a valid path or if this include restriction file       
@@ -112,12 +113,16 @@
     
     #import the FULL model
     model = import_full_model(model_path, decay, prefix)
-    
+
     if os.path.exists(pjoin(model_path, "README")):
         logger.info("Please read carefully the README of the model file for instructions/restrictions of the model.",'$MG:color:BLACK') 
     # restore the model name
     if restrict_name:
         model["name"] += '-' + restrict_name
+    
+    # Decide whether complex mass scheme is on or not
+    useCMS = (complex_mass_scheme is None and aloha.complex_mass) or \
+                                                      complex_mass_scheme==True
     #restrict it if needed       
     if restrict_file:
         try:
@@ -130,14 +135,36 @@
             logger.info('Run \"set stdout_level DEBUG\" before import for more information.')
         # Modify the mother class of the object in order to allow restriction
         model = RestrictModel(model)
+
+        # Change to complex mass scheme if necessary. This must be done BEFORE
+        # the restriction.
+        if useCMS:
+            # We read the param_card a first time so that the function 
+            # change_mass_to_complex_scheme can know if a particle is to
+            # be considered massive or not and with zero width or not.
+            # So we read the restrict card a first time, with the CMS set to
+            # False because we haven't changed the model yet.
+            model.set_parameters_and_couplings(param_card = restrict_file,
+                                                      complex_mass_scheme=False)
+            model.change_mass_to_complex_scheme(toCMS=True)
+        else:
+            model.change_mass_to_complex_scheme(toCMS=False)
+
         if model_name == 'mssm' or os.path.basename(model_name) == 'mssm':
             keep_external=True
         else:
             keep_external=False
         model.restrict_model(restrict_file, rm_parameter=not decay,
-                                            keep_external=keep_external)
+           keep_external=keep_external, complex_mass_scheme=complex_mass_scheme)
         model.path = model_path
+    else:
+        # Change to complex mass scheme if necessary
+        if useCMS:
+            model.change_mass_to_complex_scheme(toCMS=True)
+        else:
+            model.change_mass_to_complex_scheme(toCMS=False)
 
+        
     return model
     
 
@@ -263,8 +290,8 @@
     # save in a pickle files to fasten future usage
     if ReadWrite:
         save_load_object.save_to_file(os.path.join(model_path, pickle_name),
-                                   model, log=False) 
- 
+                                   model, log=False)
+
     #if default and os.path.exists(os.path.join(model_path, 'restrict_default.dat')):
     #    restrict_file = os.path.join(model_path, 'restrict_default.dat') 
     #    model = import_ufo.RestrictModel(model)
@@ -1488,7 +1515,8 @@
         self.rule_card = check_param_card.ParamCardRule()
         self.restrict_card = None
      
-    def restrict_model(self, param_card, rm_parameter=True, keep_external=False):
+    def restrict_model(self, param_card, rm_parameter=True, keep_external=False,
+                                                      complex_mass_scheme=None):
         """apply the model restriction following param_card.
         rm_parameter defines if the Zero/one parameter are removed or not from
         the model.
@@ -1502,6 +1530,11 @@
         self.set('particles', self.get('particles'))
 
         # compute the value of all parameters
+        # Get the list of definition of model functions, parameter values. 
+        self.set_parameters_and_couplings(param_card, 
+                                        complex_mass_scheme=complex_mass_scheme)
+        
+        
         # Keep the list of definition of model functions, parameter values. 
         model_definitions = self.set_parameters_and_couplings(param_card)
         

=== added file 'models/loop_qcd_qed_sm/.restrict_parallel_test_MB.dat'
--- models/loop_qcd_qed_sm/.restrict_parallel_test_MB.dat	1970-01-01 00:00:00 +0000
+++ models/loop_qcd_qed_sm/.restrict_parallel_test_MB.dat	2015-08-16 06:06:34 +0000
@@ -0,0 +1,65 @@
+######################################################################
+## PARAM_CARD AUTOMATICALY GENERATED BY THE UFO  #####################
+######################################################################
+
+###################################
+### INFORMATION FOR LOOP
+####################################
+Block LOOP
+  666 1.00000000e+03 # MU_R
+
+###################################
+## INFORMATION FOR SMINPUTS
+###################################
+Block SMINPUTS 
+    1 1.32506980e+02 # aEWM1  
+    3 1.18000000e-01 # aS 
+
+###################################
+## INFORMATION FOR MASS
+###################################
+Block MASS 
+    1 0.000000e+00 # MD
+    2 0.000000e+00 # MU
+    3 0.000000e+00 # MS
+    4 0.000000e+00 # MC 
+    5 4.500000e+00 # MB
+    6 1.743000e+02 # MT 
+   11 0.000000e+00 # Me 
+   13 0.000000e+00 # MM 
+   15 0.000000e+00 # MTA
+   23 9.118800e+01 # MZ
+   24 8.041900e+01 # MW
+   25 1.200000e+02 # MH
+
+###################################
+## INFORMATION FOR DECAY
+###################################
+DECAY   6 0.000000e+00
+DECAY  15 0.000000e+00
+DECAY  23 0.000000e+00
+DECAY  24 0.000000e+00
+DECAY  25 0.000000e+00
+
+###################################
+## INFORMATION FOR WOLFENSTEIN
+###################################
+Block Wolfenstein 
+    1 0.000000e+00 # lamWS 
+    2 0.000000e+00 # AWS 
+    3 0.000000e+00 # rhoWS 
+    4 0.000000e+00 # etaWS 
+
+###################################
+## INFORMATION FOR YUKAWA
+###################################
+Block YUKAWA 
+    1 0.000000e+00 # ymdo
+    2 0.000000e+00 # ymup
+    3 0.000000e+00 # yms
+    4 0.000000e+00 # ymc 
+    5 4.500000e+00 # ymb
+    6 1.743000e+02 # ymt 
+   11 0.000000e+00 # yme 
+   13 0.000000e+00 # ymm 
+   15 0.000000e+00 # ymtau

=== modified file 'models/loop_qcd_qed_sm/CT_couplings.py'
--- models/loop_qcd_qed_sm/CT_couplings.py	2015-07-15 01:32:18 +0000
+++ models/loop_qcd_qed_sm/CT_couplings.py	2015-08-16 06:06:34 +0000
@@ -4,7 +4,7 @@
 
 from object_library import all_couplings, Coupling
 
-from function_library import complexconjugate, re, im, csc, sec, acsc, asec, arg, reglog
+from function_library import complexconjugate, re, im, csc, sec, acsc, asec, arg, reglog, reglogp, reglogm, recms
 
 ################
 # R2 couplings #
@@ -1754,7 +1754,7 @@
                      order = {'QED':3})
 
 R2_ssA2Cm = Coupling(name = 'R2_ssA2Cm',
-                     value = '((1./4.)*((1+lhv)/(4.*cw**2)*(-1./27.)+MS**2/(8*sw**2*MW**2)*(-1./3.))*(1./2.))*(-complex(0,1)*R2SFF)',
+                     value = '((1./4.)*((1+lhv)/(4.*cw**2)*(-1./27.)+MS**2/(8*sw**2*MW**2)*(-1./3.)*(1./2.))*(-complex(0,1)*R2SFF))',
                      order = {'QED':3})
 
 R2_ssA2Cm_u = Coupling(name = 'R2_ssA2Cm_u',

=== modified file 'models/loop_qcd_qed_sm/CT_parameters.py'
--- models/loop_qcd_qed_sm/CT_parameters.py	2015-07-08 18:54:36 +0000
+++ models/loop_qcd_qed_sm/CT_parameters.py	2015-08-16 06:06:34 +0000
@@ -4,7 +4,7 @@
 
 from object_library import all_CTparameters, CTParameter
 
-from function_library import complexconjugate, re, im, csc, sec, acsc, asec, arg, reglog
+from function_library import complexconjugate, re, im, csc, sec, acsc, asec, arg, reglog,reglogp,reglogm, recms
 
 ################
 # R2 vertices  #
@@ -174,131 +174,131 @@
 
 dMB_HiggsTadpole_UV_EW = CTParameter(name = 'dMB_HiggsTadpole_UV_EW',
                                      type = 'complex',
-                                     value = {-1:'( 0 if MB == 0 else re((ee*MB**4*Ncol)/(8.*MW*cmath.pi**2*sw)) )',
-                                               0:'( 0 if MB == 0 else re((ee*MB**4*Ncol*(1 + reglog(MU_R**2/MB**2)))/(8.*MW*cmath.pi**2*sw)) )'},
+                                     value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0,(ee*MB**4*Ncol)/(8.*MW*cmath.pi**2*sw)) )',
+                                               0:'( 0 if MB == 0 else recms(CMSParam==1.0,(ee*MB**4*Ncol*(1 - reglog(MB**2/MU_R**2)))/(8.*MW*cmath.pi**2*sw)) )'},
                                      texname = '\delta ht^{EW,MB}')
 
 
 dMB_tMass_UV_EW = CTParameter(name = 'dMB_tMass_UV_EW',
                               type = 'complex',
-                              value = {-1:'( 0 if MB == 0 else re((-3*ee**2*MB**2*MT)/(128.*MW**2*cmath.pi**2*sw**2)) )',
-                                        0:'( 0 if MB == 0 else re((ee**2*(9*cw**2*MB**4 - 45*cw**2*MB**2*MT**2 + 9*cw**2*MB**2*MW**2 - 9*cw**2*MT**4*reglog(16.) + 48*MT**2*MW**2*sw**2*reglog(16.) - 64*cw**2*MT**2*MW**2*sw**2*reglog(16.) - 64*MT**2*MW**2*sw**4*reglog(16.) - 45*cw**2*MT**4*reglog(cmath.pi) - 18*cw**2*MT**2*MW**2*reglog(cmath.pi) + 192*MT**2*MW**2*sw**2*reglog(cmath.pi) - 272*cw**2*MT**2*MW**2*sw**2*reglog(cmath.pi) - 256*MT**2*MW**2*sw**4*reglog(cmath.pi) + 54*cw**2*MT**4*reglog(2*cmath.pi) + 36*cw**2*MT**2*MW**2*reglog(2*cmath.pi) - 192*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 288*cw**2*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 256*MT**2*MW**2*sw**4*reglog(2*cmath.pi) - 9*cw**2*MT**4*reglog(4*cmath.pi) - 18*cw**2*MT**2*MW**2*reglog(4*cmath.pi) - 16*cw**2*MT**2*MW**2*sw**2*reglog(4*cmath.pi)))/(1152.*cw**2*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*MB**2*(MB**2 + MT**2 + 2*MW**2)*reglog(MU_R**2/MB**2))/(128.*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*(MT**4 - MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*reglog(MU_R**2/MW**2))/(128.*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*reglog((MT**2 + vep*complex(0,-1))/MU_R**2))/(128.*MT*MW**2*cmath.pi**2*sw**2) + (ee**2*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*reglog((-MT**2 + MW**2 + vep*complex(0,-1))/MW**2))/(128.*MT**3*MW**2*cmath.pi**2*sw**2) - (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*reglog((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MT*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*(MB**2 + MT**2 - MW**2 + cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4 + MT**2*vep*complex(0,4)))*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))))/(256.*MT**3*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*(MB**2 + MT**2 - MW**2 - cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4 + MT**2*vep*complex(0,4)))*reglog((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))))/(256.*MT**3*MW**2*cmath.pi**2*sw**2)) )'},
+                              value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0 and WT != 0,(-3*ee**2*MB**2*MT)/(128.*MW**2*cmath.pi**2*sw**2)) )',
+                                        0:'( 0 if MB == 0 else recms(CMSParam==1.0 and WT != 0,(ee**2*(9*cw**2*MB**4 - 45*cw**2*MB**2*MT**2 + 9*cw**2*MB**2*MW**2 - 9*cw**2*MT**4*reglog(16.) + 48*MT**2*MW**2*sw**2*reglog(16.) - 64*cw**2*MT**2*MW**2*sw**2*reglog(16.) - 64*MT**2*MW**2*sw**4*reglog(16.) - 45*cw**2*MT**4*reglog(cmath.pi) - 18*cw**2*MT**2*MW**2*reglog(cmath.pi) + 192*MT**2*MW**2*sw**2*reglog(cmath.pi) - 272*cw**2*MT**2*MW**2*sw**2*reglog(cmath.pi) - 256*MT**2*MW**2*sw**4*reglog(cmath.pi) + 54*cw**2*MT**4*reglog(2*cmath.pi) + 36*cw**2*MT**2*MW**2*reglog(2*cmath.pi) - 192*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 288*cw**2*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 256*MT**2*MW**2*sw**4*reglog(2*cmath.pi) - 9*cw**2*MT**4*reglog(4*cmath.pi) - 18*cw**2*MT**2*MW**2*reglog(4*cmath.pi) - 16*cw**2*MT**2*MW**2*sw**2*reglog(4*cmath.pi)))/(1152.*cw**2*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*MB**2*(MB**2 + MT**2 + 2*MW**2)*(-reglog(MB**2/MU_R**2)))/(128.*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*(MT**4 - MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*reglog(MU_R**2/MW**2))/(128.*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*reglog((MT**2 + vep*complex(0,-1))/MU_R**2))/(128.*MT*MW**2*cmath.pi**2*sw**2) + (ee**2*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*reglogm((-MT**2 + MW**2 + vep*complex(0,-1))/MW**2))/(128.*MT**3*MW**2*cmath.pi**2*sw**2) - (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*reglogm((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MT*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*(MB**2 + MT**2 - MW**2 + cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4 + MT**2*vep*complex(0,4)))*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))))/(256.*MT**3*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*(MB**2 + MT**2 - MW**2 - cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4 + MT**2*vep*complex(0,4)))*reglogm((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))))/(256.*MT**3*MW**2*cmath.pi**2*sw**2)) )'},
                               texname = '\delta m_t^{EW,MB}')
 
 
 dMB_bMass_UV_EW = CTParameter(name = 'dMB_bMass_UV_EW',
                               type = 'complex',
-                              value = {-1:'( 0 if MB == 0 else re((ee**2*MB*(MW**2*(3 + 12*sw**2 - 8*sw**4) + cw**2*(9*MB**2 - 9*MT**2 + 2*MW**2*(3 - 4*sw**2))))/(384.*cw**2*MW**2*cmath.pi**2*sw**2)) )',
-                                        0:'( 0 if MB == 0 else re(-(ee**2*(-72*cw**2*MB**4 + 9*cw**2*MB**2*MH**2 + 45*cw**2*MB**2*MT**2 - 9*cw**2*MT**4 - 18*MB**2*MW**2 - 9*cw**2*MB**2*MW**2 - 9*cw**2*MT**2*MW**2 + 18*cw**2*MW**4 + 9*cw**2*MB**2*MZ**2 + 9*MW**2*MZ**2 - 48*MB**2*MW**2*sw**2 + 32*cw**2*MB**2*MW**2*sw**2 - 12*MW**2*MZ**2*sw**2 + 32*MB**2*MW**2*sw**4 + 8*MW**2*MZ**2*sw**4 - 9*cw**2*MB**4*reglog(16.) - 24*MB**2*MW**2*sw**2*reglog(16.) + 16*cw**2*MB**2*MW**2*sw**2*reglog(16.) + 16*MB**2*MW**2*sw**4*reglog(16.) + 9*cw**2*MB**4*reglog(1/(4.*cmath.pi)) + 9*MB**2*MW**2*reglog(1/(4.*cmath.pi)) - 12*MB**2*MW**2*sw**2*reglog(1/(4.*cmath.pi)) + 4*MB**2*MW**2*sw**4*reglog(1/(4.*cmath.pi)) - 18*cw**2*MB**4*reglog(cmath.pi) + 18*cw**2*MB**2*MW**2*reglog(cmath.pi) - 48*MB**2*MW**2*sw**2*reglog(cmath.pi) + 40*cw**2*MB**2*MW**2*sw**2*reglog(cmath.pi) + 32*MB**2*MW**2*sw**4*reglog(cmath.pi) - 36*cw**2*MB**2*MW**2*reglog(2*cmath.pi) - 16*cw**2*MB**2*MW**2*sw**2*reglog(2*cmath.pi) + 27*cw**2*MB**4*reglog(4*cmath.pi) + 9*MB**2*MW**2*reglog(4*cmath.pi) + 18*cw**2*MB**2*MW**2*reglog(4*cmath.pi) + 36*MB**2*MW**2*sw**2*reglog(4*cmath.pi) - 24*cw**2*MB**2*MW**2*sw**2*reglog(4*cmath.pi) - 28*MB**2*MW**2*sw**4*reglog(4*cmath.pi)))/(1152.*cw**2*MB*MW**2*cmath.pi**2*sw**2) - (ee**2*MB*(18*cw**2*MB**2 + 9*MW**2 - 12*MW**2*sw**2 + 24*cw**2*MW**2*sw**2 + 8*MW**2*sw**4)*reglog(MU_R**2/MB**2))/(1152.*cw**2*MW**2*cmath.pi**2*sw**2) + (ee**2*MB*MH**2*reglog(MU_R**2/MH**2))/(128.*MW**2*cmath.pi**2*sw**2) - (ee**2*MT**2*(MB**2 + MT**2 + 2*MW**2)*reglog(MU_R**2/MT**2))/(128.*MB*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**2 + MT**2 + 2*MW**2)*reglog(MU_R**2/MW**2))/(128.*MB*cmath.pi**2*sw**2) + (ee**2*MZ**2*(9*cw**2*MB**2 + 9*MW**2 - 12*MW**2*sw**2 + 8*MW**2*sw**4)*reglog(MU_R**2/MZ**2))/(1152.*cw**2*MB*MW**2*cmath.pi**2*sw**2) - (ee**2*(45*cw**2*MB**4 - 9*cw**2*MB**2*MH**2 - 18*cw**2*MB**2*MT**2 + 9*cw**2*MT**4 + 18*MB**2*MW**2 + 9*cw**2*MB**2*MW**2 + 9*cw**2*MT**2*MW**2 - 18*cw**2*MW**4 - 9*cw**2*MB**2*MZ**2 - 9*MW**2*MZ**2 + 24*MB**2*MW**2*sw**2 + 12*MW**2*MZ**2*sw**2 - 16*MB**2*MW**2*sw**4 - 8*MW**2*MZ**2*sw**4)*reglog((MB**2 + vep*complex(0,-1))/MU_R**2))/(1152.*cw**2*MB*MW**2*cmath.pi**2*sw**2) - (ee**2*MB*(2*MB - MH)*(2*MB + MH)*reglog((-MH**2 - cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MW**2*cmath.pi**2*sw**2) - (ee**2*MB*(2*MB - MH)*(2*MB + MH)*reglog((-MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MW**2*cmath.pi**2*sw**2) + (ee**2*(2*MB - MH)*(2*MB + MH)*(2*MB**2 - MH**2 + cmath.sqrt(-4*MB**2*MH**2 + MH**4 + MB**2*vep*complex(0,4)))*reglog((-MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2*MB**2 - MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))))/(256.*MB*MW**2*cmath.pi**2*sw**2) + (ee**2*(2*MB - MH)*(2*MB + MH)*(2*MB**2 - MH**2 - cmath.sqrt(-4*MB**2*MH**2 + MH**4 + MB**2*vep*complex(0,4)))*reglog((MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(-2*MB**2 + MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))))/(256.*MB*MW**2*cmath.pi**2*sw**2) - (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*reglog((-MB**2 + MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MB*MW**2*cmath.pi**2*sw**2) - (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*reglog((-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MB*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))*reglog((-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))))/(256.*MB**3*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*(MB**2 + MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))*reglog((MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))))/(256.*MB**3*MW**2*cmath.pi**2*sw**2) + (ee**2*(-18*MB**2*MW**2 + 9*cw**2*MB**2*MZ**2 + 9*MW**2*MZ**2 - 24*MB**2*MW**2*sw**2 - 12*MW**2*MZ**2*sw**2 + 16*MB**2*MW**2*sw**4 + 8*MW**2*MZ**2*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2.*MB**2)))/(1152.*cw**2*MB*MW**2*cmath.pi**2*sw**2) + (ee**2*(-18*MB**2*MW**2 + 9*cw**2*MB**2*MZ**2 + 9*MW**2*MZ**2 - 24*MB**2*MW**2*sw**2 - 12*MW**2*MZ**2*sw**2 + 16*MB**2*MW**2*sw**4 + 8*MW**2*MZ**2*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2.*MB**2)))/(1152.*cw**2*MB*MW**2*cmath.pi**2*sw**2) - (ee**2*(-18*MB**2*MW**2 + 9*cw**2*MB**2*MZ**2 + 9*MW**2*MZ**2 - 24*MB**2*MW**2*sw**2 - 12*MW**2*MZ**2*sw**2 + 16*MB**2*MW**2*sw**4 + 8*MW**2*MZ**2*sw**4)*(2*MB**2 - MZ**2 + cmath.sqrt(-4*MB**2*MZ**2 + MZ**4 + MB**2*vep*complex(0,4)))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2*MB**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))))/(2304.*cw**2*MB**3*MW**2*cmath.pi**2*sw**2) - (ee**2*(-18*MB**2*MW**2 + 9*cw**2*MB**2*MZ**2 + 9*MW**2*MZ**2 - 24*MB**2*MW**2*sw**2 - 12*MW**2*MZ**2*sw**2 + 16*MB**2*MW**2*sw**4 + 8*MW**2*MZ**2*sw**4)*(2*MB**2 - MZ**2 - cmath.sqrt(-4*MB**2*MZ**2 + MZ**4 + MB**2*vep*complex(0,4)))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(-2*MB**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))))/(2304.*cw**2*MB**3*MW**2*cmath.pi**2*sw**2)) )'},
+                              value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0,(ee**2*MB*(MW**2*(3 + 12*sw**2 - 8*sw**4) + cw**2*(9*MB**2 - 9*MT**2 + 2*MW**2*(3 - 4*sw**2))))/(384.*cw**2*MW**2*cmath.pi**2*sw**2)) )',
+                                        0:'( 0 if MB == 0 else recms(CMSParam==1.0,-(ee**2*(-72*cw**2*MB**4 + 9*cw**2*MB**2*MH**2 + 45*cw**2*MB**2*MT**2 - 9*cw**2*MT**4 - 18*MB**2*MW**2 - 9*cw**2*MB**2*MW**2 - 9*cw**2*MT**2*MW**2 + 18*cw**2*MW**4 + 9*cw**2*MB**2*MZ**2 + 9*MW**2*MZ**2 - 48*MB**2*MW**2*sw**2 + 32*cw**2*MB**2*MW**2*sw**2 - 12*MW**2*MZ**2*sw**2 + 32*MB**2*MW**2*sw**4 + 8*MW**2*MZ**2*sw**4 - 9*cw**2*MB**4*reglog(16.) - 24*MB**2*MW**2*sw**2*reglog(16.) + 16*cw**2*MB**2*MW**2*sw**2*reglog(16.) + 16*MB**2*MW**2*sw**4*reglog(16.) + 9*cw**2*MB**4*reglog(1/(4.*cmath.pi)) + 9*MB**2*MW**2*reglog(1/(4.*cmath.pi)) - 12*MB**2*MW**2*sw**2*reglog(1/(4.*cmath.pi)) + 4*MB**2*MW**2*sw**4*reglog(1/(4.*cmath.pi)) - 18*cw**2*MB**4*reglog(cmath.pi) + 18*cw**2*MB**2*MW**2*reglog(cmath.pi) - 48*MB**2*MW**2*sw**2*reglog(cmath.pi) + 40*cw**2*MB**2*MW**2*sw**2*reglog(cmath.pi) + 32*MB**2*MW**2*sw**4*reglog(cmath.pi) - 36*cw**2*MB**2*MW**2*reglog(2*cmath.pi) - 16*cw**2*MB**2*MW**2*sw**2*reglog(2*cmath.pi) + 27*cw**2*MB**4*reglog(4*cmath.pi) + 9*MB**2*MW**2*reglog(4*cmath.pi) + 18*cw**2*MB**2*MW**2*reglog(4*cmath.pi) + 36*MB**2*MW**2*sw**2*reglog(4*cmath.pi) - 24*cw**2*MB**2*MW**2*sw**2*reglog(4*cmath.pi) - 28*MB**2*MW**2*sw**4*reglog(4*cmath.pi)))/(1152.*cw**2*MB*MW**2*cmath.pi**2*sw**2) - (ee**2*MB*(18*cw**2*MB**2 + 9*MW**2 - 12*MW**2*sw**2 + 24*cw**2*MW**2*sw**2 + 8*MW**2*sw**4)*(-reglog(MB**2/MU_R**2)))/(1152.*cw**2*MW**2*cmath.pi**2*sw**2) + (ee**2*MB*MH**2*reglog(MU_R**2/MH**2))/(128.*MW**2*cmath.pi**2*sw**2) - (ee**2*MT**2*(MB**2 + MT**2 + 2*MW**2)*reglog(MU_R**2/MT**2))/(128.*MB*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**2 + MT**2 + 2*MW**2)*reglog(MU_R**2/MW**2))/(128.*MB*cmath.pi**2*sw**2) + (ee**2*MZ**2*(9*cw**2*MB**2 + 9*MW**2 - 12*MW**2*sw**2 + 8*MW**2*sw**4)*reglog(MU_R**2/MZ**2))/(1152.*cw**2*MB*MW**2*cmath.pi**2*sw**2) - (ee**2*(45*cw**2*MB**4 - 9*cw**2*MB**2*MH**2 - 18*cw**2*MB**2*MT**2 + 9*cw**2*MT**4 + 18*MB**2*MW**2 + 9*cw**2*MB**2*MW**2 + 9*cw**2*MT**2*MW**2 - 18*cw**2*MW**4 - 9*cw**2*MB**2*MZ**2 - 9*MW**2*MZ**2 + 24*MB**2*MW**2*sw**2 + 12*MW**2*MZ**2*sw**2 - 16*MB**2*MW**2*sw**4 - 8*MW**2*MZ**2*sw**4)*reglog((MB**2 + vep*complex(0,-1))/MU_R**2))/(1152.*cw**2*MB*MW**2*cmath.pi**2*sw**2) - (ee**2*MB*(2*MB - MH)*(2*MB + MH)*reglogm((-MH**2 - cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MW**2*cmath.pi**2*sw**2) - (ee**2*MB*(2*MB - MH)*(2*MB + MH)*reglogm((-MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MW**2*cmath.pi**2*sw**2) + (ee**2*(2*MB - MH)*(2*MB + MH)*(2*MB**2 - MH**2 + cmath.sqrt(-4*MB**2*MH**2 + MH**4 + MB**2*vep*complex(0,4)))*reglogm((-MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2*MB**2 - MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))))/(256.*MB*MW**2*cmath.pi**2*sw**2) + (ee**2*(2*MB - MH)*(2*MB + MH)*(2*MB**2 - MH**2 - cmath.sqrt(-4*MB**2*MH**2 + MH**4 + MB**2*vep*complex(0,4)))*reglogm((MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(-2*MB**2 + MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))))/(256.*MB*MW**2*cmath.pi**2*sw**2) - (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*reglogm((-MB**2 + MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MB*MW**2*cmath.pi**2*sw**2) - (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*reglogm((-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MB*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))*reglogm((-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))))/(256.*MB**3*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**4 - 2*MB**2*MT**2 + MT**4 + MB**2*MW**2 + MT**2*MW**2 - 2*MW**4)*(MB**2 + MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))*reglogm((MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))))/(256.*MB**3*MW**2*cmath.pi**2*sw**2) + (ee**2*(-18*MB**2*MW**2 + 9*cw**2*MB**2*MZ**2 + 9*MW**2*MZ**2 - 24*MB**2*MW**2*sw**2 - 12*MW**2*MZ**2*sw**2 + 16*MB**2*MW**2*sw**4 + 8*MW**2*MZ**2*sw**4)*reglogm((-MZ**2 - cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2.*MB**2)))/(1152.*cw**2*MB*MW**2*cmath.pi**2*sw**2) + (ee**2*(-18*MB**2*MW**2 + 9*cw**2*MB**2*MZ**2 + 9*MW**2*MZ**2 - 24*MB**2*MW**2*sw**2 - 12*MW**2*MZ**2*sw**2 + 16*MB**2*MW**2*sw**4 + 8*MW**2*MZ**2*sw**4)*reglogm((-MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2.*MB**2)))/(1152.*cw**2*MB*MW**2*cmath.pi**2*sw**2) - (ee**2*(-18*MB**2*MW**2 + 9*cw**2*MB**2*MZ**2 + 9*MW**2*MZ**2 - 24*MB**2*MW**2*sw**2 - 12*MW**2*MZ**2*sw**2 + 16*MB**2*MW**2*sw**4 + 8*MW**2*MZ**2*sw**4)*(2*MB**2 - MZ**2 + cmath.sqrt(-4*MB**2*MZ**2 + MZ**4 + MB**2*vep*complex(0,4)))*reglogm((-MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2*MB**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))))/(2304.*cw**2*MB**3*MW**2*cmath.pi**2*sw**2) - (ee**2*(-18*MB**2*MW**2 + 9*cw**2*MB**2*MZ**2 + 9*MW**2*MZ**2 - 24*MB**2*MW**2*sw**2 - 12*MW**2*MZ**2*sw**2 + 16*MB**2*MW**2*sw**4 + 8*MW**2*MZ**2*sw**4)*(2*MB**2 - MZ**2 - cmath.sqrt(-4*MB**2*MZ**2 + MZ**4 + MB**2*vep*complex(0,4)))*reglogm((MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(-2*MB**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))))/(2304.*cw**2*MB**3*MW**2*cmath.pi**2*sw**2)) )'},
                               texname = '\delta m_t^{EW,MB}')
 
 
 dMB_HMass2_UV_EW = CTParameter(name = 'dMB_HMass2_UV_EW',
                                type = 'complex',
-                               value = {-1:'( 0 if MB == 0 else re(-(ee**2*MB**2*(6*MB**2 - MH**2)*Ncol)/(32.*MW**2*cmath.pi**2*sw**2)) )',
-                                         0:'( 0 if MB == 0 else re((ee**2*MB**2*Ncol*(-40*MB**2 + 8*MH**2 + MH**2*reglog(256.) - MB**2*reglog(281474976710656.) - 24*MB**2*reglog(cmath.pi) + 4*MH**2*reglog(cmath.pi) + 4*(6*MB**2 - MH**2)*reglog(4*cmath.pi) - 8*MB**2*reglog(MU_R**2/MB**2) + 4*(2*MB - MH)*(2*MB + MH)*reglog((MH**2 + vep*complex(0,-1))/MU_R**2) + 4*(2*MB - MH)*(2*MB + MH)*reglog((-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(2.*MH**2)) - (2*(2*MB - MH)*(2*MB + MH)*(MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))))/MH**2 + 4*(2*MB - MH)*(2*MB + MH)*reglog(-(MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(2.*MH**2)) + (2*(-2*MB + MH)*(2*MB + MH)*(MH**2 - cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))))/MH**2))/(128.*MW**2*cmath.pi**2*sw**2)) )'},
+                               value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0 and WH != 0,-(ee**2*MB**2*(6*MB**2 - MH**2)*Ncol)/(32.*MW**2*cmath.pi**2*sw**2)) )',
+                                         0:'( 0 if MB == 0 else recms(CMSParam==1.0 and WH != 0,(ee**2*MB**2*Ncol*(-40*MB**2 + 8*MH**2 + MH**2*reglog(256.) - MB**2*reglog(281474976710656.) - 24*MB**2*reglog(cmath.pi) + 4*MH**2*reglog(cmath.pi) + 4*(6*MB**2 - MH**2)*reglog(4*cmath.pi) - 8*MB**2*(-reglog(MB**2/MU_R**2)) + 4*(2*MB - MH)*(2*MB + MH)*reglog((MH**2 + vep*complex(0,-1))/MU_R**2) + 4*(2*MB - MH)*(2*MB + MH)*reglogm((-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(2.*MH**2)) - (2*(2*MB - MH)*(2*MB + MH)*(MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))*reglogm((-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))))/MH**2 + 4*(2*MB - MH)*(2*MB + MH)*reglogm(-(MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(2.*MH**2)) + (2*(-2*MB + MH)*(2*MB + MH)*(MH**2 - cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))*reglogm((MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))))/MH**2))/(128.*MW**2*cmath.pi**2*sw**2)) )'},
                                texname = '\delta m2_H^{EW,MB}')
 
 
 dMB_WMass2_UV_EW = CTParameter(name = 'dMB_WMass2_UV_EW',
                                type = 'complex',
-                               value = {-1:'( 0 if MB == 0 else re(-(ee**2*MB**2*Ncol)/(32.*cmath.pi**2*sw**2)) )',
-                                         0:'( 0 if MB == 0 else re((ee**2*Ncol*(6*MB**2*reglog(4*cmath.pi) + (-2*MB**2*MW**2*(MB**2 - 2*MT**2 + MW**2*(2 + reglog(64.) + 3*reglog(cmath.pi))) + 2*MB**2*MW**2*(MB**2 - MT**2 - 2*MW**2)*reglog(MU_R**2/MB**2) + 2*MW**2*(-(MB**2*MT**2) + MT**4 + MT**2*MW**2 - 2*MW**4)*reglog(MU_R**2/MT**2) + 2*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglog((MW**2 + vep*complex(0,-1))/MU_R**2) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)) - (MB**4 + MT**4 + MT**2*MW**2 - 2*MW**4 + MB**2*(-2*MT**2 + MW**2))*(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglog(-(-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)) + (MB**4 + MT**4 + MT**2*MW**2 - 2*MW**4 + MB**2*(-2*MT**2 + MW**2))*(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglog((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))))/MW**4))/(192.*cmath.pi**2*sw**2)) )'},
+                               value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0 and WW != 0,-(ee**2*MB**2*Ncol)/(32.*cmath.pi**2*sw**2)) )',
+                                         0:'( 0 if MB == 0 else recms(CMSParam==1.0 and WW != 0,(ee**2*Ncol*(6*MB**2*reglog(4*cmath.pi) + (-2*MB**2*MW**2*(MB**2 - 2*MT**2 + MW**2*(2 + reglog(64.) + 3*reglog(cmath.pi))) + 2*MB**2*MW**2*(MB**2 - MT**2 - 2*MW**2)*(-reglog(MB**2/MU_R**2)) + 2*MW**2*(-(MB**2*MT**2) + MT**4 + MT**2*MW**2 - 2*MW**4)*reglog(MU_R**2/MT**2) + 2*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*reglogm((MT**2 - MW**2 + vep*complex(0,-1))/MT**2) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglog((MW**2 + vep*complex(0,-1))/MU_R**2) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)) - (MB**4 + MT**4 + MT**2*MW**2 - 2*MW**4 + MB**2*(-2*MT**2 + MW**2))*(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglogm(-(-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)) + (MB**4 + MT**4 + MT**2*MW**2 - 2*MW**4 + MB**2*(-2*MT**2 + MW**2))*(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglogm((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))))/MW**4))/(192.*cmath.pi**2*sw**2)) )'},
                                texname = '\delta m2_W^{EW,MB}')
 
 
 dMB_ZMass2_UV_EW = CTParameter(name = 'dMB_ZMass2_UV_EW',
                                type = 'complex',
-                               value = {-1:'( 0 if MB == 0 else re(-(ee**2*MB**2*Ncol)/(32.*cw**2*cmath.pi**2*sw**2)) )',
-                                         0:'( 0 if MB == 0 else re((ee**2*(2*MB**2*Ncol*(-48*sw**2 + 32*sw**4 - reglog(18014398509481984.) - 9*(2 + 3*reglog(cmath.pi))) + 54*MB**2*Ncol*reglog(4*cmath.pi) - 4*MB**2*Ncol*(9 - 12*sw**2 + 8*sw**4)*reglog(MU_R**2/MB**2) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2) + 4*MZ**2*(27*(1 - 2*sw**2 + 4*sw**4) + 2*Ncol*(9 - 18*sw**2 + 20*sw**4))*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 2*MZ**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog(-(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**2))/(1728.*cw**2*cmath.pi**2*sw**2)) )'},
+                               value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0 and WZ != 0,-(ee**2*MB**2*Ncol)/(32.*cw**2*cmath.pi**2*sw**2)) )',
+                                         0:'( 0 if MB == 0 else recms(CMSParam==1.0 and WZ != 0,(ee**2*(2*MB**2*Ncol*(-48*sw**2 + 32*sw**4 - reglog(18014398509481984.) - 9*(2 + 3*reglog(cmath.pi))) + 54*MB**2*Ncol*reglog(4*cmath.pi) - 4*MB**2*Ncol*(9 - 12*sw**2 + 8*sw**4)*(-reglog(MB**2/MU_R**2)) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2) + 4*MZ**2*(27*(1 - 2*sw**2 + 4*sw**4) + 2*Ncol*(9 - 18*sw**2 + 20*sw**4))*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 2*MZ**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglogm(-(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**2))/(1728.*cw**2*cmath.pi**2*sw**2)) )'},
                                texname = '\delta m2_Z^{EW,MB}')
 
 
 dMB_tWcft_UV_EW_R = CTParameter(name = 'dMB_tWcft_UV_EW_R',
                                 type = 'complex',
-                                value = {                                          0:'( 0 if MB == 0 else re((ee**2*(18*MB**4 - 18*MB**2*MT**2 + 18*MB**2*MW**2 + 9*MT**4*reglog(16.) - 32*MT**2*MW**2*sw**2*reglog(16.) + 16*MT**2*MW**2*sw**2*reglog(64.) + 36*MT**4*reglog(cmath.pi) - 32*MT**2*MW**2*sw**2*reglog(cmath.pi) - 36*MT**4*reglog(2*cmath.pi) + 32*MT**2*MW**2*sw**2*reglog(2*cmath.pi)))/(576.*MT**2*MW**2*cmath.pi**2*sw**2) - (ee**2*MB**2*(2*MB**6 - 5*MB**4*MT**2 + 4*MB**2*MT**4 - MT**6 - 4*MB**2*MT**2*MW**2 - 6*MB**2*MW**4 - 3*MT**2*MW**4 + 4*MW**6)*reglog(MU_R**2/MB**2))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**4*MT**4 - 2*MB**2*MT**6 + MT**8 + 2*MB**6*MW**2 - 3*MB**4*MT**2*MW**2 - 2*MB**2*MT**4*MW**2 - MT**6*MW**2 - 2*MB**2*MT**2*MW**4 + 3*MT**4*MW**4 - 6*MB**2*MW**6 - 7*MT**2*MW**6 + 4*MW**8)*reglog(MU_R**2/MW**2))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(2*MB**8 - 5*MB**6*MT**2 + 3*MB**4*MT**4 + MB**2*MT**6 - MT**8 - 2*MB**6*MW**2 - MB**4*MT**2*MW**2 + 2*MB**2*MT**4*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - MB**2*MT**2*MW**4 - 3*MT**4*MW**4 + 10*MB**2*MW**6 + 7*MT**2*MW**6 - 4*MW**8)*reglog((MT**2 + vep*complex(0,-1))/MU_R**2))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MT - MW)*(MT + MW)*(MT**4 + MT**2*MW**2 + 4*MW**4)*reglog((-MT**2 + MW**2 + vep*complex(0,-1))/MW**2))/(64.*MT**4*MW**2*cmath.pi**2*sw**2) - (ee**2*(2*MB**8 - 5*MB**6*MT**2 + 3*MB**4*MT**4 + MB**2*MT**6 - MT**8 - 2*MB**6*MW**2 - MB**4*MT**2*MW**2 + 2*MB**2*MT**4*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - MB**2*MT**2*MW**4 - 3*MT**4*MW**4 + 10*MB**2*MW**6 + 7*MT**2*MW**6 - 4*MW**8)*reglog((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(2.*MT**2)))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(2*MB**8 - 5*MB**6*MT**2 + 3*MB**4*MT**4 + MB**2*MT**6 - MT**8 - 2*MB**6*MW**2 - MB**4*MT**2*MW**2 + 2*MB**2*MT**4*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - MB**2*MT**2*MW**4 - 3*MT**4*MW**4 + 10*MB**2*MW**6 + 7*MT**2*MW**6 - 4*MW**8)*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(2.*MT**2)))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(2*MB**8 - 5*MB**6*MT**2 + 3*MB**4*MT**4 + MB**2*MT**6 - MT**8 - 2*MB**6*MW**2 - MB**4*MT**2*MW**2 + 2*MB**2*MT**4*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - MB**2*MT**2*MW**4 - 3*MT**4*MW**4 + 10*MB**2*MW**6 + 7*MT**2*MW**6 - 4*MW**8)*(MB**2 + MT**2 - MW**2 + cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4 + MT**2*vep*complex(0,4)))*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))))/(128.*MT**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(2*MB**8 - 5*MB**6*MT**2 + 3*MB**4*MT**4 + MB**2*MT**6 - MT**8 - 2*MB**6*MW**2 - MB**4*MT**2*MW**2 + 2*MB**2*MT**4*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - MB**2*MT**2*MW**4 - 3*MT**4*MW**4 + 10*MB**2*MW**6 + 7*MT**2*MW**6 - 4*MW**8)*(-MB**2 - MT**2 + MW**2 + cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4 + MT**2*vep*complex(0,4)))*reglog((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))))/(128.*MT**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2)) )'},
+                                value = {                                          0:'( 0 if MB == 0 else recms(CMSParam==1.0 and WT != 0,(ee**2*(18*MB**4 - 18*MB**2*MT**2 + 18*MB**2*MW**2 + 9*MT**4*reglog(16.) - 32*MT**2*MW**2*sw**2*reglog(16.) + 16*MT**2*MW**2*sw**2*reglog(64.) + 36*MT**4*reglog(cmath.pi) - 32*MT**2*MW**2*sw**2*reglog(cmath.pi) - 36*MT**4*reglog(2*cmath.pi) + 32*MT**2*MW**2*sw**2*reglog(2*cmath.pi)))/(576.*MT**2*MW**2*cmath.pi**2*sw**2) - (ee**2*MB**2*(2*MB**6 - 5*MB**4*MT**2 + 4*MB**2*MT**4 - MT**6 - 4*MB**2*MT**2*MW**2 - 6*MB**2*MW**4 - 3*MT**2*MW**4 + 4*MW**6)*(-reglog(MB**2/MU_R**2)))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**4*MT**4 - 2*MB**2*MT**6 + MT**8 + 2*MB**6*MW**2 - 3*MB**4*MT**2*MW**2 - 2*MB**2*MT**4*MW**2 - MT**6*MW**2 - 2*MB**2*MT**2*MW**4 + 3*MT**4*MW**4 - 6*MB**2*MW**6 - 7*MT**2*MW**6 + 4*MW**8)*reglog(MU_R**2/MW**2))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(2*MB**8 - 5*MB**6*MT**2 + 3*MB**4*MT**4 + MB**2*MT**6 - MT**8 - 2*MB**6*MW**2 - MB**4*MT**2*MW**2 + 2*MB**2*MT**4*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - MB**2*MT**2*MW**4 - 3*MT**4*MW**4 + 10*MB**2*MW**6 + 7*MT**2*MW**6 - 4*MW**8)*reglog((MT**2 + vep*complex(0,-1))/MU_R**2))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MT - MW)*(MT + MW)*(MT**4 + MT**2*MW**2 + 4*MW**4)*reglogm((-MT**2 + MW**2 + vep*complex(0,-1))/MW**2))/(64.*MT**4*MW**2*cmath.pi**2*sw**2) - (ee**2*(2*MB**8 - 5*MB**6*MT**2 + 3*MB**4*MT**4 + MB**2*MT**6 - MT**8 - 2*MB**6*MW**2 - MB**4*MT**2*MW**2 + 2*MB**2*MT**4*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - MB**2*MT**2*MW**4 - 3*MT**4*MW**4 + 10*MB**2*MW**6 + 7*MT**2*MW**6 - 4*MW**8)*reglogm((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(2.*MT**2)))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(2*MB**8 - 5*MB**6*MT**2 + 3*MB**4*MT**4 + MB**2*MT**6 - MT**8 - 2*MB**6*MW**2 - MB**4*MT**2*MW**2 + 2*MB**2*MT**4*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - MB**2*MT**2*MW**4 - 3*MT**4*MW**4 + 10*MB**2*MW**6 + 7*MT**2*MW**6 - 4*MW**8)*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(2.*MT**2)))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(2*MB**8 - 5*MB**6*MT**2 + 3*MB**4*MT**4 + MB**2*MT**6 - MT**8 - 2*MB**6*MW**2 - MB**4*MT**2*MW**2 + 2*MB**2*MT**4*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - MB**2*MT**2*MW**4 - 3*MT**4*MW**4 + 10*MB**2*MW**6 + 7*MT**2*MW**6 - 4*MW**8)*(MB**2 + MT**2 - MW**2 + cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4 + MT**2*vep*complex(0,4)))*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))))/(128.*MT**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(2*MB**8 - 5*MB**6*MT**2 + 3*MB**4*MT**4 + MB**2*MT**6 - MT**8 - 2*MB**6*MW**2 - MB**4*MT**2*MW**2 + 2*MB**2*MT**4*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - MB**2*MT**2*MW**4 - 3*MT**4*MW**4 + 10*MB**2*MW**6 + 7*MT**2*MW**6 - 4*MW**8)*(-MB**2 - MT**2 + MW**2 + cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4 + MT**2*vep*complex(0,4)))*reglogm((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))))/(128.*MT**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2)) )'},
                                 texname = '\delta ZR_t^{EW,MB}')
 
 
 dMB_bWcft_UV_EW_R = CTParameter(name = 'dMB_bWcft_UV_EW_R',
                                 type = 'complex',
-                                value = {-1:'( 0 if MB == 0 else re(-(ee**2*(3*MB**2 + 2*MW**2*sw**2))/(96.*MW**2*cmath.pi**2*sw**2)) )',
-                                          0:'( 0 if MB == 0 else re(-(ee**2*(-36*cw**2*MB**4 + 27*cw**2*MB**2*MH**2 + 36*cw**2*MB**2*MT**2 - 36*cw**2*MT**4 - 54*MB**2*MW**2 - 18*cw**2*MB**2*MW**2 - 36*cw**2*MT**2*MW**2 + 72*cw**2*MW**4 + 27*cw**2*MB**2*MZ**2 + 36*MW**2*MZ**2 - 24*MB**2*MW**2*sw**2 + 32*cw**2*MB**2*MW**2*sw**2 - 48*MW**2*MZ**2*sw**2 + 36*MB**2*MW**2*sw**4 + 24*MW**2*MZ**2*sw**4 + 18*cw**2*MB**4*reglog(16.) + 16*cw**2*MB**2*MW**2*sw**2*reglog(16.) - 4*MB**2*MW**2*sw**4*reglog(16.) - 4*cw**2*MB**2*MW**2*sw**2*reglog(256.) + 36*cw**2*MB**4*reglog(cmath.pi) + 8*cw**2*MB**2*MW**2*sw**2*reglog(cmath.pi) - 8*MB**2*MW**2*sw**4*reglog(cmath.pi) + 16*cw**2*MB**2*MW**2*sw**2*reglog(2*cmath.pi) - 36*cw**2*MB**4*reglog(4*cmath.pi) - 24*cw**2*MB**2*MW**2*sw**2*reglog(4*cmath.pi) + 8*MB**2*MW**2*sw**4*reglog(4*cmath.pi)))/(1152.*cw**2*MB**2*MW**2*cmath.pi**2*sw**2) - (ee**2*(24*cw**2*MB**4 + 18*MB**2*MW**2 - 9*cw**2*MB**2*MZ**2 - 6*MW**2*MZ**2 - 8*MB**2*MW**2*sw**2 + 16*cw**2*MB**2*MW**2*sw**2 + 8*MW**2*MZ**2*sw**2 - 4*cw**2*MW**2*MZ**2*sw**2 - 4*MW**2*MZ**2*sw**4)*reglog(MU_R**2/MB**2))/(192.*cw**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (ee**2*(4*MB**2 - 3*MH**2)*reglog(MU_R**2/MH**2))/(128.*MW**2*cmath.pi**2*sw**2) + (ee**2*MT**2*(MB**6 - 4*MB**4*MT**2 + 5*MB**2*MT**4 - 2*MT**6 + 4*MB**2*MT**2*MW**2 + 3*MB**2*MW**4 + 6*MT**2*MW**4 - 4*MW**6)*reglog(MU_R**2/MT**2))/(64.*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**6 - 3*MB**2*MT**4 + 2*MT**6 + 2*MB**4*MW**2 - 2*MB**2*MT**2*MW**2 - 7*MB**2*MW**4 - 6*MT**2*MW**4 + 4*MW**6)*reglog(MU_R**2/MW**2))/(64.*MB**2*(MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(-24*MB**4*MW**2 + 24*cw**2*MB**4*MZ**2 + 48*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 12*MW**2*MZ**4 - 32*MB**4*MW**2*sw**2 - 32*MB**2*MW**2*MZ**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 8*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*reglog(MU_R**2/MZ**2))/(384.*cw**2*MB**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (ee**2*(48*cw**2*MB**10 - 36*cw**2*MB**8*MH**2 - 120*cw**2*MB**8*MT**2 + 72*cw**2*MB**6*MH**2*MT**2 + 144*cw**2*MB**6*MT**4 - 36*cw**2*MB**4*MH**2*MT**4 - 120*cw**2*MB**4*MT**6 + 48*cw**2*MB**2*MT**8 + 60*MB**8*MW**2 - 120*cw**2*MB**8*MW**2 + 72*cw**2*MB**6*MH**2*MW**2 - 120*MB**6*MT**2*MW**2 - 96*cw**2*MB**6*MT**2*MW**2 + 72*cw**2*MB**4*MH**2*MT**2*MW**2 + 60*MB**4*MT**4*MW**2 - 24*cw**2*MB**4*MT**4*MW**2 - 48*cw**2*MB**2*MT**6*MW**2 - 120*MB**6*MW**4 - 36*cw**2*MB**4*MH**2*MW**4 - 120*MB**4*MT**2*MW**4 - 24*cw**2*MB**4*MT**2*MW**4 - 144*cw**2*MB**2*MT**4*MW**4 + 60*MB**4*MW**6 + 168*cw**2*MB**4*MW**6 + 240*cw**2*MB**2*MT**2*MW**6 - 96*cw**2*MB**2*MW**8 - 42*cw**2*MB**8*MZ**2 + 9*cw**2*MB**6*MH**2*MZ**2 + 90*cw**2*MB**6*MT**2*MZ**2 - 18*cw**2*MB**4*MH**2*MT**2*MZ**2 - 66*cw**2*MB**4*MT**4*MZ**2 + 9*cw**2*MB**2*MH**2*MT**4*MZ**2 + 30*cw**2*MB**2*MT**6*MZ**2 - 12*cw**2*MT**8*MZ**2 - 60*MB**6*MW**2*MZ**2 + 90*cw**2*MB**6*MW**2*MZ**2 - 18*cw**2*MB**4*MH**2*MW**2*MZ**2 + 120*MB**4*MT**2*MW**2*MZ**2 + 84*cw**2*MB**4*MT**2*MW**2*MZ**2 - 18*cw**2*MB**2*MH**2*MT**2*MW**2*MZ**2 - 60*MB**2*MT**4*MW**2*MZ**2 + 6*cw**2*MB**2*MT**4*MW**2*MZ**2 + 12*cw**2*MT**6*MW**2*MZ**2 + 120*MB**4*MW**4*MZ**2 - 30*cw**2*MB**4*MW**4*MZ**2 + 9*cw**2*MB**2*MH**2*MW**4*MZ**2 + 120*MB**2*MT**2*MW**4*MZ**2 + 6*cw**2*MB**2*MT**2*MW**4*MZ**2 + 36*cw**2*MT**4*MW**4*MZ**2 - 60*MB**2*MW**6*MZ**2 - 42*cw**2*MB**2*MW**6*MZ**2 - 60*cw**2*MT**2*MW**6*MZ**2 + 24*cw**2*MW**8*MZ**2 + 9*cw**2*MB**6*MZ**4 - 18*cw**2*MB**4*MT**2*MZ**4 + 9*cw**2*MB**2*MT**4*MZ**4 + 12*MB**4*MW**2*MZ**4 - 18*cw**2*MB**4*MW**2*MZ**4 - 24*MB**2*MT**2*MW**2*MZ**4 - 18*cw**2*MB**2*MT**2*MW**2*MZ**4 + 12*MT**4*MW**2*MZ**4 - 24*MB**2*MW**4*MZ**4 + 9*cw**2*MB**2*MW**4*MZ**4 - 24*MT**2*MW**4*MZ**4 + 12*MW**6*MZ**4 + 16*MB**8*MW**2*sw**2 - 32*MB**6*MT**2*MW**2*sw**2 + 16*MB**4*MT**4*MW**2*sw**2 - 32*MB**6*MW**4*sw**2 - 32*MB**4*MT**2*MW**4*sw**2 + 16*MB**4*MW**6*sw**2 + 48*MB**6*MW**2*MZ**2*sw**2 - 96*MB**4*MT**2*MW**2*MZ**2*sw**2 + 48*MB**2*MT**4*MW**2*MZ**2*sw**2 - 96*MB**4*MW**4*MZ**2*sw**2 - 96*MB**2*MT**2*MW**4*MZ**2*sw**2 + 48*MB**2*MW**6*MZ**2*sw**2 - 16*MB**4*MW**2*MZ**4*sw**2 + 32*MB**2*MT**2*MW**2*MZ**4*sw**2 - 16*MT**4*MW**2*MZ**4*sw**2 + 32*MB**2*MW**4*MZ**4*sw**2 + 32*MT**2*MW**4*MZ**4*sw**2 - 16*MW**6*MZ**4*sw**2 - 32*MB**8*MW**2*sw**4 + 64*MB**6*MT**2*MW**2*sw**4 - 32*MB**4*MT**4*MW**2*sw**4 + 64*MB**6*MW**4*sw**4 + 64*MB**4*MT**2*MW**4*sw**4 - 32*MB**4*MW**6*sw**4 - 16*MB**6*MW**2*MZ**2*sw**4 + 32*MB**4*MT**2*MW**2*MZ**2*sw**4 - 16*MB**2*MT**4*MW**2*MZ**2*sw**4 + 32*MB**4*MW**4*MZ**2*sw**4 + 32*MB**2*MT**2*MW**4*MZ**2*sw**4 - 16*MB**2*MW**6*MZ**2*sw**4 + 8*MB**4*MW**2*MZ**4*sw**4 - 16*MB**2*MT**2*MW**2*MZ**4*sw**4 + 8*MT**4*MW**2*MZ**4*sw**4 - 16*MB**2*MW**4*MZ**4*sw**4 - 16*MT**2*MW**4*MZ**4*sw**4 + 8*MW**6*MZ**4*sw**4)*reglog((MB**2 + vep*complex(0,-1))/MU_R**2))/(384.*cw**2*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (3*ee**2*(2*MB**2 - MH**2)*reglog((-MH**2 - cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MW**2*cmath.pi**2*sw**2) - (3*ee**2*(2*MB**2 - MH**2)*reglog((-MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MW**2*cmath.pi**2*sw**2) + (3*ee**2*(2*MB**2 - MH**2)*(2*MB**2 - MH**2 + cmath.sqrt(-4*MB**2*MH**2 + MH**4 + MB**2*vep*complex(0,4)))*reglog((-MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2*MB**2 - MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))))/(256.*MB**2*MW**2*cmath.pi**2*sw**2) - (3*ee**2*(2*MB**2 - MH**2)*(-2*MB**2 + MH**2 + cmath.sqrt(-4*MB**2*MH**2 + MH**4 + MB**2*vep*complex(0,4)))*reglog((MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(-2*MB**2 + MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))))/(256.*MB**2*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**8 - MB**6*MT**2 - 3*MB**4*MT**4 + 5*MB**2*MT**6 - 2*MT**8 - MB**6*MW**2 - 2*MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 + 2*MT**6*MW**2 + 3*MB**4*MW**4 + MB**2*MT**2*MW**4 + 6*MT**4*MW**4 - 7*MB**2*MW**6 - 10*MT**2*MW**6 + 4*MW**8)*reglog((-MB**2 + MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(2.*MB**2)))/(64.*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**8 - MB**6*MT**2 - 3*MB**4*MT**4 + 5*MB**2*MT**6 - 2*MT**8 - MB**6*MW**2 - 2*MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 + 2*MT**6*MW**2 + 3*MB**4*MW**4 + MB**2*MT**2*MW**4 + 6*MT**4*MW**4 - 7*MB**2*MW**6 - 10*MT**2*MW**6 + 4*MW**8)*reglog((-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(2.*MB**2)))/(64.*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**8 - MB**6*MT**2 - 3*MB**4*MT**4 + 5*MB**2*MT**6 - 2*MT**8 - MB**6*MW**2 - 2*MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 + 2*MT**6*MW**2 + 3*MB**4*MW**4 + MB**2*MT**2*MW**4 + 6*MT**4*MW**4 - 7*MB**2*MW**6 - 10*MT**2*MW**6 + 4*MW**8)*(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))*reglog((-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))))/(128.*MB**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**8 - MB**6*MT**2 - 3*MB**4*MT**4 + 5*MB**2*MT**6 - 2*MT**8 - MB**6*MW**2 - 2*MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 + 2*MT**6*MW**2 + 3*MB**4*MW**4 + MB**2*MT**2*MW**4 + 6*MT**4*MW**4 - 7*MB**2*MW**6 - 10*MT**2*MW**6 + 4*MW**8)*(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))*reglog((MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))))/(128.*MB**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(-60*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 60*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 12*MW**2*MZ**4 - 16*MB**4*MW**2*sw**2 - 48*MB**2*MW**2*MZ**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2.*MB**2)))/(384.*cw**2*MB**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) + (ee**2*(-60*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 60*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 12*MW**2*MZ**4 - 16*MB**4*MW**2*sw**2 - 48*MB**2*MW**2*MZ**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2.*MB**2)))/(384.*cw**2*MB**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (ee**2*(-60*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 60*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 12*MW**2*MZ**4 - 16*MB**4*MW**2*sw**2 - 48*MB**2*MW**2*MZ**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*(2*MB**2 - MZ**2 + cmath.sqrt(-4*MB**2*MZ**2 + MZ**4 + MB**2*vep*complex(0,4)))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2*MB**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MB**4*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) + (ee**2*(-60*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 60*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 12*MW**2*MZ**4 - 16*MB**4*MW**2*sw**2 - 48*MB**2*MW**2*MZ**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*(-2*MB**2 + MZ**2 + cmath.sqrt(-4*MB**2*MZ**2 + MZ**4 + MB**2*vep*complex(0,4)))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(-2*MB**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MB**4*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2)) )'},
+                                value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0,-(ee**2*(3*MB**2 + 2*MW**2*sw**2))/(96.*MW**2*cmath.pi**2*sw**2)) )',
+                                          0:'( 0 if MB == 0 else recms(CMSParam==1.0,-(ee**2*(-36*cw**2*MB**4 + 27*cw**2*MB**2*MH**2 + 36*cw**2*MB**2*MT**2 - 36*cw**2*MT**4 - 54*MB**2*MW**2 - 18*cw**2*MB**2*MW**2 - 36*cw**2*MT**2*MW**2 + 72*cw**2*MW**4 + 27*cw**2*MB**2*MZ**2 + 36*MW**2*MZ**2 - 24*MB**2*MW**2*sw**2 + 32*cw**2*MB**2*MW**2*sw**2 - 48*MW**2*MZ**2*sw**2 + 36*MB**2*MW**2*sw**4 + 24*MW**2*MZ**2*sw**4 + 18*cw**2*MB**4*reglog(16.) + 16*cw**2*MB**2*MW**2*sw**2*reglog(16.) - 4*MB**2*MW**2*sw**4*reglog(16.) - 4*cw**2*MB**2*MW**2*sw**2*reglog(256.) + 36*cw**2*MB**4*reglog(cmath.pi) + 8*cw**2*MB**2*MW**2*sw**2*reglog(cmath.pi) - 8*MB**2*MW**2*sw**4*reglog(cmath.pi) + 16*cw**2*MB**2*MW**2*sw**2*reglog(2*cmath.pi) - 36*cw**2*MB**4*reglog(4*cmath.pi) - 24*cw**2*MB**2*MW**2*sw**2*reglog(4*cmath.pi) + 8*MB**2*MW**2*sw**4*reglog(4*cmath.pi)))/(1152.*cw**2*MB**2*MW**2*cmath.pi**2*sw**2) - (ee**2*(24*cw**2*MB**4 + 18*MB**2*MW**2 - 9*cw**2*MB**2*MZ**2 - 6*MW**2*MZ**2 - 8*MB**2*MW**2*sw**2 + 16*cw**2*MB**2*MW**2*sw**2 + 8*MW**2*MZ**2*sw**2 - 4*cw**2*MW**2*MZ**2*sw**2 - 4*MW**2*MZ**2*sw**4)*(-reglog(MB**2/MU_R**2)))/(192.*cw**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (ee**2*(4*MB**2 - 3*MH**2)*reglog(MU_R**2/MH**2))/(128.*MW**2*cmath.pi**2*sw**2) + (ee**2*MT**2*(MB**6 - 4*MB**4*MT**2 + 5*MB**2*MT**4 - 2*MT**6 + 4*MB**2*MT**2*MW**2 + 3*MB**2*MW**4 + 6*MT**2*MW**4 - 4*MW**6)*reglog(MU_R**2/MT**2))/(64.*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**6 - 3*MB**2*MT**4 + 2*MT**6 + 2*MB**4*MW**2 - 2*MB**2*MT**2*MW**2 - 7*MB**2*MW**4 - 6*MT**2*MW**4 + 4*MW**6)*reglog(MU_R**2/MW**2))/(64.*MB**2*(MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(-24*MB**4*MW**2 + 24*cw**2*MB**4*MZ**2 + 48*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 12*MW**2*MZ**4 - 32*MB**4*MW**2*sw**2 - 32*MB**2*MW**2*MZ**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 8*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*reglog(MU_R**2/MZ**2))/(384.*cw**2*MB**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (ee**2*(48*cw**2*MB**10 - 36*cw**2*MB**8*MH**2 - 120*cw**2*MB**8*MT**2 + 72*cw**2*MB**6*MH**2*MT**2 + 144*cw**2*MB**6*MT**4 - 36*cw**2*MB**4*MH**2*MT**4 - 120*cw**2*MB**4*MT**6 + 48*cw**2*MB**2*MT**8 + 60*MB**8*MW**2 - 120*cw**2*MB**8*MW**2 + 72*cw**2*MB**6*MH**2*MW**2 - 120*MB**6*MT**2*MW**2 - 96*cw**2*MB**6*MT**2*MW**2 + 72*cw**2*MB**4*MH**2*MT**2*MW**2 + 60*MB**4*MT**4*MW**2 - 24*cw**2*MB**4*MT**4*MW**2 - 48*cw**2*MB**2*MT**6*MW**2 - 120*MB**6*MW**4 - 36*cw**2*MB**4*MH**2*MW**4 - 120*MB**4*MT**2*MW**4 - 24*cw**2*MB**4*MT**2*MW**4 - 144*cw**2*MB**2*MT**4*MW**4 + 60*MB**4*MW**6 + 168*cw**2*MB**4*MW**6 + 240*cw**2*MB**2*MT**2*MW**6 - 96*cw**2*MB**2*MW**8 - 42*cw**2*MB**8*MZ**2 + 9*cw**2*MB**6*MH**2*MZ**2 + 90*cw**2*MB**6*MT**2*MZ**2 - 18*cw**2*MB**4*MH**2*MT**2*MZ**2 - 66*cw**2*MB**4*MT**4*MZ**2 + 9*cw**2*MB**2*MH**2*MT**4*MZ**2 + 30*cw**2*MB**2*MT**6*MZ**2 - 12*cw**2*MT**8*MZ**2 - 60*MB**6*MW**2*MZ**2 + 90*cw**2*MB**6*MW**2*MZ**2 - 18*cw**2*MB**4*MH**2*MW**2*MZ**2 + 120*MB**4*MT**2*MW**2*MZ**2 + 84*cw**2*MB**4*MT**2*MW**2*MZ**2 - 18*cw**2*MB**2*MH**2*MT**2*MW**2*MZ**2 - 60*MB**2*MT**4*MW**2*MZ**2 + 6*cw**2*MB**2*MT**4*MW**2*MZ**2 + 12*cw**2*MT**6*MW**2*MZ**2 + 120*MB**4*MW**4*MZ**2 - 30*cw**2*MB**4*MW**4*MZ**2 + 9*cw**2*MB**2*MH**2*MW**4*MZ**2 + 120*MB**2*MT**2*MW**4*MZ**2 + 6*cw**2*MB**2*MT**2*MW**4*MZ**2 + 36*cw**2*MT**4*MW**4*MZ**2 - 60*MB**2*MW**6*MZ**2 - 42*cw**2*MB**2*MW**6*MZ**2 - 60*cw**2*MT**2*MW**6*MZ**2 + 24*cw**2*MW**8*MZ**2 + 9*cw**2*MB**6*MZ**4 - 18*cw**2*MB**4*MT**2*MZ**4 + 9*cw**2*MB**2*MT**4*MZ**4 + 12*MB**4*MW**2*MZ**4 - 18*cw**2*MB**4*MW**2*MZ**4 - 24*MB**2*MT**2*MW**2*MZ**4 - 18*cw**2*MB**2*MT**2*MW**2*MZ**4 + 12*MT**4*MW**2*MZ**4 - 24*MB**2*MW**4*MZ**4 + 9*cw**2*MB**2*MW**4*MZ**4 - 24*MT**2*MW**4*MZ**4 + 12*MW**6*MZ**4 + 16*MB**8*MW**2*sw**2 - 32*MB**6*MT**2*MW**2*sw**2 + 16*MB**4*MT**4*MW**2*sw**2 - 32*MB**6*MW**4*sw**2 - 32*MB**4*MT**2*MW**4*sw**2 + 16*MB**4*MW**6*sw**2 + 48*MB**6*MW**2*MZ**2*sw**2 - 96*MB**4*MT**2*MW**2*MZ**2*sw**2 + 48*MB**2*MT**4*MW**2*MZ**2*sw**2 - 96*MB**4*MW**4*MZ**2*sw**2 - 96*MB**2*MT**2*MW**4*MZ**2*sw**2 + 48*MB**2*MW**6*MZ**2*sw**2 - 16*MB**4*MW**2*MZ**4*sw**2 + 32*MB**2*MT**2*MW**2*MZ**4*sw**2 - 16*MT**4*MW**2*MZ**4*sw**2 + 32*MB**2*MW**4*MZ**4*sw**2 + 32*MT**2*MW**4*MZ**4*sw**2 - 16*MW**6*MZ**4*sw**2 - 32*MB**8*MW**2*sw**4 + 64*MB**6*MT**2*MW**2*sw**4 - 32*MB**4*MT**4*MW**2*sw**4 + 64*MB**6*MW**4*sw**4 + 64*MB**4*MT**2*MW**4*sw**4 - 32*MB**4*MW**6*sw**4 - 16*MB**6*MW**2*MZ**2*sw**4 + 32*MB**4*MT**2*MW**2*MZ**2*sw**4 - 16*MB**2*MT**4*MW**2*MZ**2*sw**4 + 32*MB**4*MW**4*MZ**2*sw**4 + 32*MB**2*MT**2*MW**4*MZ**2*sw**4 - 16*MB**2*MW**6*MZ**2*sw**4 + 8*MB**4*MW**2*MZ**4*sw**4 - 16*MB**2*MT**2*MW**2*MZ**4*sw**4 + 8*MT**4*MW**2*MZ**4*sw**4 - 16*MB**2*MW**4*MZ**4*sw**4 - 16*MT**2*MW**4*MZ**4*sw**4 + 8*MW**6*MZ**4*sw**4)*reglogm((MB**2 + vep*complex(0,-1))/MU_R**2))/(384.*cw**2*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (3*ee**2*(2*MB**2 - MH**2)*reglogm((-MH**2 - cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MW**2*cmath.pi**2*sw**2) - (3*ee**2*(2*MB**2 - MH**2)*reglogm((-MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MW**2*cmath.pi**2*sw**2) + (3*ee**2*(2*MB**2 - MH**2)*(2*MB**2 - MH**2 + cmath.sqrt(-4*MB**2*MH**2 + MH**4 + MB**2*vep*complex(0,4)))*reglogm((-MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2*MB**2 - MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))))/(256.*MB**2*MW**2*cmath.pi**2*sw**2) - (3*ee**2*(2*MB**2 - MH**2)*(-2*MB**2 + MH**2 + cmath.sqrt(-4*MB**2*MH**2 + MH**4 + MB**2*vep*complex(0,4)))*reglogm((MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(-2*MB**2 + MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))))/(256.*MB**2*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**8 - MB**6*MT**2 - 3*MB**4*MT**4 + 5*MB**2*MT**6 - 2*MT**8 - MB**6*MW**2 - 2*MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 + 2*MT**6*MW**2 + 3*MB**4*MW**4 + MB**2*MT**2*MW**4 + 6*MT**4*MW**4 - 7*MB**2*MW**6 - 10*MT**2*MW**6 + 4*MW**8)*reglogm((-MB**2 + MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(2.*MB**2)))/(64.*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**8 - MB**6*MT**2 - 3*MB**4*MT**4 + 5*MB**2*MT**6 - 2*MT**8 - MB**6*MW**2 - 2*MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 + 2*MT**6*MW**2 + 3*MB**4*MW**4 + MB**2*MT**2*MW**4 + 6*MT**4*MW**4 - 7*MB**2*MW**6 - 10*MT**2*MW**6 + 4*MW**8)*reglogm((-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(2.*MB**2)))/(64.*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**8 - MB**6*MT**2 - 3*MB**4*MT**4 + 5*MB**2*MT**6 - 2*MT**8 - MB**6*MW**2 - 2*MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 + 2*MT**6*MW**2 + 3*MB**4*MW**4 + MB**2*MT**2*MW**4 + 6*MT**4*MW**4 - 7*MB**2*MW**6 - 10*MT**2*MW**6 + 4*MW**8)*(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))*reglogm((-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))))/(128.*MB**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**8 - MB**6*MT**2 - 3*MB**4*MT**4 + 5*MB**2*MT**6 - 2*MT**8 - MB**6*MW**2 - 2*MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 + 2*MT**6*MW**2 + 3*MB**4*MW**4 + MB**2*MT**2*MW**4 + 6*MT**4*MW**4 - 7*MB**2*MW**6 - 10*MT**2*MW**6 + 4*MW**8)*(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))*reglogm((MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))))/(128.*MB**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(-60*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 60*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 12*MW**2*MZ**4 - 16*MB**4*MW**2*sw**2 - 48*MB**2*MW**2*MZ**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*reglogm((-MZ**2 - cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2.*MB**2)))/(384.*cw**2*MB**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) + (ee**2*(-60*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 60*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 12*MW**2*MZ**4 - 16*MB**4*MW**2*sw**2 - 48*MB**2*MW**2*MZ**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*reglogm((-MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2.*MB**2)))/(384.*cw**2*MB**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (ee**2*(-60*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 60*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 12*MW**2*MZ**4 - 16*MB**4*MW**2*sw**2 - 48*MB**2*MW**2*MZ**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*(2*MB**2 - MZ**2 + cmath.sqrt(-4*MB**2*MZ**2 + MZ**4 + MB**2*vep*complex(0,4)))*reglogm((-MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2*MB**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MB**4*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) + (ee**2*(-60*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 60*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 12*MW**2*MZ**4 - 16*MB**4*MW**2*sw**2 - 48*MB**2*MW**2*MZ**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*(-2*MB**2 + MZ**2 + cmath.sqrt(-4*MB**2*MZ**2 + MZ**4 + MB**2*vep*complex(0,4)))*reglogm((MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(-2*MB**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MB**4*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2)) )'},
                                 texname = '\delta ZR_b^{EW,MB}')
 
 dMB_tWcft_UV_EW_L = CTParameter(name = 'dMB_tWcft_UV_EW_L',
                                 type = 'complex',
-                                value = {-1:'( 0 if MB == 0 else re(-(ee**2*MB**2)/(64.*MW**2*cmath.pi**2*sw**2)) )',
-                                          0:'( 0 if MB == 0 else re((ee**2*(9*MB**4 - 27*MB**2*MT**2 + 9*MB**2*MW**2 - 32*MT**2*MW**2*sw**2*reglog(16.) + 16*MT**2*MW**2*sw**2*reglog(64.) + 9*MT**4*reglog(cmath.pi) + 18*MT**2*MW**2*reglog(cmath.pi) - 32*MT**2*MW**2*sw**2*reglog(cmath.pi) - 18*MT**4*reglog(2*cmath.pi) - 36*MT**2*MW**2*reglog(2*cmath.pi) + 32*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 9*MT**4*reglog(4*cmath.pi) + 18*MT**2*MW**2*reglog(4*cmath.pi)))/(576.*MT**2*MW**2*cmath.pi**2*sw**2) - (ee**2*MB**2*(MB**6 - 2*MB**4*MT**2 + MB**2*MT**4 - 4*MT**4*MW**2 - 3*MB**2*MW**4 + 2*MT**2*MW**4 + 2*MW**6)*reglog(MU_R**2/MB**2))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**6 + 2*MB**4*MT**2 - 7*MB**2*MT**4 + 4*MT**6 - 2*MB**2*MT**2*MW**2 - 6*MT**4*MW**2 - 3*MB**2*MW**4 + 2*MW**6)*reglog(MU_R**2/MW**2))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**8 - 3*MB**6*MT**2 + 3*MB**4*MT**4 - MB**2*MT**6 - MB**6*MW**2 + 5*MB**2*MT**4*MW**2 - 4*MT**6*MW**2 - 3*MB**4*MW**4 + 3*MB**2*MT**2*MW**4 + 6*MT**4*MW**4 + 5*MB**2*MW**6 - 2*MW**8)*reglog((MT**2 + vep*complex(0,-1))/MU_R**2))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MT - MW)*(MT + MW)*(2*MT**2 + MW**2)*reglog((-MT**2 + MW**2 + vep*complex(0,-1))/MW**2))/(32.*MT**4*cmath.pi**2*sw**2) - (ee**2*(MB**8 - 3*MB**6*MT**2 + 3*MB**4*MT**4 - MB**2*MT**6 - MB**6*MW**2 + 5*MB**2*MT**4*MW**2 - 4*MT**6*MW**2 - 3*MB**4*MW**4 + 3*MB**2*MT**2*MW**4 + 6*MT**4*MW**4 + 5*MB**2*MW**6 - 2*MW**8)*reglog((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(2.*MT**2)))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**8 - 3*MB**6*MT**2 + 3*MB**4*MT**4 - MB**2*MT**6 - MB**6*MW**2 + 5*MB**2*MT**4*MW**2 - 4*MT**6*MW**2 - 3*MB**4*MW**4 + 3*MB**2*MT**2*MW**4 + 6*MT**4*MW**4 + 5*MB**2*MW**6 - 2*MW**8)*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(2.*MT**2)))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**8 - 3*MB**6*MT**2 + 3*MB**4*MT**4 - MB**2*MT**6 - MB**6*MW**2 + 5*MB**2*MT**4*MW**2 - 4*MT**6*MW**2 - 3*MB**4*MW**4 + 3*MB**2*MT**2*MW**4 + 6*MT**4*MW**4 + 5*MB**2*MW**6 - 2*MW**8)*(MB**2 + MT**2 - MW**2 + cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4 + MT**2*vep*complex(0,4)))*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))))/(128.*MT**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**8 - 3*MB**6*MT**2 + 3*MB**4*MT**4 - MB**2*MT**6 - MB**6*MW**2 + 5*MB**2*MT**4*MW**2 - 4*MT**6*MW**2 - 3*MB**4*MW**4 + 3*MB**2*MT**2*MW**4 + 6*MT**4*MW**4 + 5*MB**2*MW**6 - 2*MW**8)*(-MB**2 - MT**2 + MW**2 + cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4 + MT**2*vep*complex(0,4)))*reglog((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))))/(128.*MT**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2)) )'},
+                                value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0 and WT != 0,-(ee**2*MB**2)/(64.*MW**2*cmath.pi**2*sw**2)) )',
+                                          0:'( 0 if MB == 0 else recms(CMSParam==1.0 and WT != 0,(ee**2*(9*MB**4 - 27*MB**2*MT**2 + 9*MB**2*MW**2 - 32*MT**2*MW**2*sw**2*reglog(16.) + 16*MT**2*MW**2*sw**2*reglog(64.) + 9*MT**4*reglog(cmath.pi) + 18*MT**2*MW**2*reglog(cmath.pi) - 32*MT**2*MW**2*sw**2*reglog(cmath.pi) - 18*MT**4*reglog(2*cmath.pi) - 36*MT**2*MW**2*reglog(2*cmath.pi) + 32*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 9*MT**4*reglog(4*cmath.pi) + 18*MT**2*MW**2*reglog(4*cmath.pi)))/(576.*MT**2*MW**2*cmath.pi**2*sw**2) - (ee**2*MB**2*(MB**6 - 2*MB**4*MT**2 + MB**2*MT**4 - 4*MT**4*MW**2 - 3*MB**2*MW**4 + 2*MT**2*MW**4 + 2*MW**6)*(-reglog(MB**2/MU_R**2)))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**6 + 2*MB**4*MT**2 - 7*MB**2*MT**4 + 4*MT**6 - 2*MB**2*MT**2*MW**2 - 6*MT**4*MW**2 - 3*MB**2*MW**4 + 2*MW**6)*reglog(MU_R**2/MW**2))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**8 - 3*MB**6*MT**2 + 3*MB**4*MT**4 - MB**2*MT**6 - MB**6*MW**2 + 5*MB**2*MT**4*MW**2 - 4*MT**6*MW**2 - 3*MB**4*MW**4 + 3*MB**2*MT**2*MW**4 + 6*MT**4*MW**4 + 5*MB**2*MW**6 - 2*MW**8)*reglog((MT**2 + vep*complex(0,-1))/MU_R**2))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MT - MW)*(MT + MW)*(2*MT**2 + MW**2)*reglogm((-MT**2 + MW**2 + vep*complex(0,-1))/MW**2))/(32.*MT**4*cmath.pi**2*sw**2) - (ee**2*(MB**8 - 3*MB**6*MT**2 + 3*MB**4*MT**4 - MB**2*MT**6 - MB**6*MW**2 + 5*MB**2*MT**4*MW**2 - 4*MT**6*MW**2 - 3*MB**4*MW**4 + 3*MB**2*MT**2*MW**4 + 6*MT**4*MW**4 + 5*MB**2*MW**6 - 2*MW**8)*reglogm((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(2.*MT**2)))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**8 - 3*MB**6*MT**2 + 3*MB**4*MT**4 - MB**2*MT**6 - MB**6*MW**2 + 5*MB**2*MT**4*MW**2 - 4*MT**6*MW**2 - 3*MB**4*MW**4 + 3*MB**2*MT**2*MW**4 + 6*MT**4*MW**4 + 5*MB**2*MW**6 - 2*MW**8)*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(2.*MT**2)))/(64.*MT**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**8 - 3*MB**6*MT**2 + 3*MB**4*MT**4 - MB**2*MT**6 - MB**6*MW**2 + 5*MB**2*MT**4*MW**2 - 4*MT**6*MW**2 - 3*MB**4*MW**4 + 3*MB**2*MT**2*MW**4 + 6*MT**4*MW**4 + 5*MB**2*MW**6 - 2*MW**8)*(MB**2 + MT**2 - MW**2 + cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4 + MT**2*vep*complex(0,4)))*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))))/(128.*MT**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**8 - 3*MB**6*MT**2 + 3*MB**4*MT**4 - MB**2*MT**6 - MB**6*MW**2 + 5*MB**2*MT**4*MW**2 - 4*MT**6*MW**2 - 3*MB**4*MW**4 + 3*MB**2*MT**2*MW**4 + 6*MT**4*MW**4 + 5*MB**2*MW**6 - 2*MW**8)*(-MB**2 - MT**2 + MW**2 + cmath.sqrt(MB**4 - 2*MB**2*MT**2 + MT**4 - 2*MB**2*MW**2 - 2*MT**2*MW**2 + MW**4 + MT**2*vep*complex(0,4)))*reglogm((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MT**2*(MB**2 + vep*complex(0,-1))))))/(128.*MT**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2)) )'},
                                 texname = '\delta ZL_t^{EW,MB}')
 
 dMB_bWcft_UV_EW_L = CTParameter(name = 'dMB_bWcft_UV_EW_L',
                                 type = 'complex',
-                                value = {-1:'( 0 if MB == 0 else re(-(ee**2*(3*MB**2 + 4*MW**2*sw**2))/(192.*MW**2*cmath.pi**2*sw**2)) )',
-                                          0:'( 0 if MB == 0 else re((ee**2*(72*cw**2*MB**4*MT**2 - 27*cw**2*MB**2*MH**2*MT**2 - 27*cw**2*MB**2*MT**4 + 18*cw**2*MT**6 - 72*cw**2*MB**4*MW**2 + 27*cw**2*MB**2*MH**2*MW**2 + 9*MB**2*MT**2*MW**2 + 27*cw**2*MB**2*MT**2*MW**2 - 9*MB**2*MW**4 + 54*cw**2*MB**2*MW**4 - 54*cw**2*MT**2*MW**4 + 36*cw**2*MW**6 - 27*cw**2*MB**2*MT**2*MZ**2 + 27*cw**2*MB**2*MW**2*MZ**2 - 18*MT**2*MW**2*MZ**2 + 18*MW**4*MZ**2 + 84*MB**2*MT**2*MW**2*sw**2 - 32*cw**2*MB**2*MT**2*MW**2*sw**2 - 84*MB**2*MW**4*sw**2 + 32*cw**2*MB**2*MW**4*sw**2 + 24*MT**2*MW**2*MZ**2*sw**2 - 24*MW**4*MZ**2*sw**2 - 36*MB**2*MT**2*MW**2*sw**4 + 36*MB**2*MW**4*sw**4 - 24*MT**2*MW**2*MZ**2*sw**4 + 24*MW**4*MZ**2*sw**4 + 9*cw**2*MB**2*MT**4*reglog(16.) + 9*MB**2*MT**2*MW**2*reglog(16.) + 9*cw**2*MB**2*MT**2*MW**2*reglog(16.) - 9*MB**2*MW**4*reglog(16.) - 18*cw**2*MB**2*MW**4*reglog(16.) - 12*MB**2*MT**2*MW**2*sw**2*reglog(16.) - 16*cw**2*MB**2*MT**2*MW**2*sw**2*reglog(16.) + 12*MB**2*MW**4*sw**2*reglog(16.) + 16*cw**2*MB**2*MW**4*sw**2*reglog(16.) + 4*MB**2*MT**2*MW**2*sw**4*reglog(16.) - 4*MB**2*MW**4*sw**4*reglog(16.) + 4*cw**2*MB**2*MT**2*MW**2*sw**2*reglog(256.) - 4*cw**2*MB**2*MW**4*sw**2*reglog(256.) + 18*cw**2*MB**4*MT**2*reglog(1/(4.*cmath.pi)) - 18*cw**2*MB**4*MW**2*reglog(1/(4.*cmath.pi)) + 18*MB**2*MT**2*MW**2*reglog(1/(4.*cmath.pi)) - 18*MB**2*MW**4*reglog(1/(4.*cmath.pi)) - 24*MB**2*MT**2*MW**2*sw**2*reglog(1/(4.*cmath.pi)) + 24*MB**2*MW**4*sw**2*reglog(1/(4.*cmath.pi)) + 8*MB**2*MT**2*MW**2*sw**4*reglog(1/(4.*cmath.pi)) - 8*MB**2*MW**4*sw**4*reglog(1/(4.*cmath.pi)) + 18*cw**2*MB**2*MT**4*reglog(cmath.pi) + 18*MB**2*MT**2*MW**2*reglog(cmath.pi) + 54*cw**2*MB**2*MT**2*MW**2*reglog(cmath.pi) - 18*MB**2*MW**4*reglog(cmath.pi) - 72*cw**2*MB**2*MW**4*reglog(cmath.pi) - 24*MB**2*MT**2*MW**2*sw**2*reglog(cmath.pi) - 8*cw**2*MB**2*MT**2*MW**2*sw**2*reglog(cmath.pi) + 24*MB**2*MW**4*sw**2*reglog(cmath.pi) + 8*cw**2*MB**2*MW**4*sw**2*reglog(cmath.pi) + 8*MB**2*MT**2*MW**2*sw**4*reglog(cmath.pi) - 8*MB**2*MW**4*sw**4*reglog(cmath.pi) - 72*cw**2*MB**2*MT**2*MW**2*reglog(2*cmath.pi) + 72*cw**2*MB**2*MW**4*reglog(2*cmath.pi) - 16*cw**2*MB**2*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 16*cw**2*MB**2*MW**4*sw**2*reglog(2*cmath.pi) + 18*cw**2*MB**4*MT**2*reglog(4*cmath.pi) - 18*cw**2*MB**2*MT**4*reglog(4*cmath.pi) - 18*cw**2*MB**4*MW**2*reglog(4*cmath.pi) + 18*cw**2*MB**2*MT**2*MW**2*reglog(4*cmath.pi) + 24*cw**2*MB**2*MT**2*MW**2*sw**2*reglog(4*cmath.pi) - 24*cw**2*MB**2*MW**4*sw**2*reglog(4*cmath.pi)))/(1152.*cw**2*MB**2*(MT - MW)*MW**2*(MT + MW)*cmath.pi**2*sw**2) - (ee**2*(24*cw**2*MB**4 + 6*MB**2*MW**2 - 9*cw**2*MB**2*MZ**2 - 3*MW**2*MZ**2 + 8*MB**2*MW**2*sw**2 + 16*cw**2*MB**2*MW**2*sw**2 + 4*MW**2*MZ**2*sw**2 - 4*cw**2*MW**2*MZ**2*sw**2 - 4*MW**2*MZ**2*sw**4)*reglog(MU_R**2/MB**2))/(192.*cw**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (ee**2*(4*MB**2 - 3*MH**2)*reglog(MU_R**2/MH**2))/(128.*MW**2*cmath.pi**2*sw**2) + (ee**2*MT**2*(MB**6*MT**4 - 3*MB**4*MT**6 + 3*MB**2*MT**8 - MT**10 + 2*MB**6*MT**2*MW**2 - 4*MB**2*MT**6*MW**2 + 2*MT**8*MW**2 - 13*MB**4*MT**2*MW**4 - 3*MB**2*MT**4*MW**4 + 2*MT**6*MW**4 + 4*MB**4*MW**6 + 6*MB**2*MT**2*MW**6 - 8*MT**4*MW**6 - 2*MB**2*MW**8 + 7*MT**2*MW**8 - 2*MW**10)*reglog(MU_R**2/MT**2))/(64.*MB**2*(MB - MT - MW)*(MT - MW)**2*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MT + MW)**2*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(-(MB**4*MT**6) + 2*MB**2*MT**8 - MT**10 + 7*MB**6*MT**2*MW**2 - 14*MB**4*MT**4*MW**2 - 3*MB**2*MT**6*MW**2 + 2*MT**8*MW**2 - 4*MB**6*MW**4 - 3*MB**4*MT**2*MW**4 + 2*MT**6*MW**4 + 6*MB**4*MW**6 + MB**2*MT**2*MW**6 - 8*MT**4*MW**6 + 7*MT**2*MW**8 - 2*MW**10)*reglog(MU_R**2/MW**2))/(64.*MB**2*(MB - MT - MW)*(MT - MW)**2*(MB + MT - MW)*(MB - MT + MW)*(MT + MW)**2*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(24*cw**2*MB**4*MZ**2 + 18*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 6*MW**2*MZ**4 - 64*MB**4*MW**2*sw**2 + 8*MB**2*MW**2*MZ**2*sw**2 + 8*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 8*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*reglog(MU_R**2/MZ**2))/(384.*cw**2*MB**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (ee**2*(72*cw**2*MB**10 - 36*cw**2*MB**8*MH**2 - 168*cw**2*MB**8*MT**2 + 72*cw**2*MB**6*MH**2*MT**2 + 144*cw**2*MB**6*MT**4 - 36*cw**2*MB**4*MH**2*MT**4 - 72*cw**2*MB**4*MT**6 + 24*cw**2*MB**2*MT**8 + 12*MB**8*MW**2 - 240*cw**2*MB**8*MW**2 + 72*cw**2*MB**6*MH**2*MW**2 - 24*MB**6*MT**2*MW**2 - 24*cw**2*MB**6*MT**2*MW**2 + 72*cw**2*MB**4*MH**2*MT**2*MW**2 + 12*MB**4*MT**4*MW**2 - 24*cw**2*MB**2*MT**6*MW**2 - 24*MB**6*MW**4 + 216*cw**2*MB**6*MW**4 - 36*cw**2*MB**4*MH**2*MW**4 - 24*MB**4*MT**2*MW**4 + 72*cw**2*MB**4*MT**2*MW**4 - 72*cw**2*MB**2*MT**4*MW**4 + 12*MB**4*MW**6 + 120*cw**2*MB**2*MT**2*MW**6 - 48*cw**2*MB**2*MW**8 - 48*cw**2*MB**8*MZ**2 + 9*cw**2*MB**6*MH**2*MZ**2 + 102*cw**2*MB**6*MT**2*MZ**2 - 18*cw**2*MB**4*MH**2*MT**2*MZ**2 - 66*cw**2*MB**4*MT**4*MZ**2 + 9*cw**2*MB**2*MH**2*MT**4*MZ**2 + 18*cw**2*MB**2*MT**6*MZ**2 - 6*cw**2*MT**8*MZ**2 - 24*MB**6*MW**2*MZ**2 + 120*cw**2*MB**6*MW**2*MZ**2 - 18*cw**2*MB**4*MH**2*MW**2*MZ**2 + 48*MB**4*MT**2*MW**2*MZ**2 + 66*cw**2*MB**4*MT**2*MW**2*MZ**2 - 18*cw**2*MB**2*MH**2*MT**2*MW**2*MZ**2 - 24*MB**2*MT**4*MW**2*MZ**2 + 6*cw**2*MT**6*MW**2*MZ**2 + 48*MB**4*MW**4*MZ**2 - 84*cw**2*MB**4*MW**4*MZ**2 + 9*cw**2*MB**2*MH**2*MW**4*MZ**2 + 48*MB**2*MT**2*MW**4*MZ**2 - 18*cw**2*MB**2*MT**2*MW**4*MZ**2 + 18*cw**2*MT**4*MW**4*MZ**2 - 24*MB**2*MW**6*MZ**2 - 30*cw**2*MT**2*MW**6*MZ**2 + 12*cw**2*MW**8*MZ**2 + 9*cw**2*MB**6*MZ**4 - 18*cw**2*MB**4*MT**2*MZ**4 + 9*cw**2*MB**2*MT**4*MZ**4 + 6*MB**4*MW**2*MZ**4 - 18*cw**2*MB**4*MW**2*MZ**4 - 12*MB**2*MT**2*MW**2*MZ**4 - 18*cw**2*MB**2*MT**2*MW**2*MZ**4 + 6*MT**4*MW**2*MZ**4 - 12*MB**2*MW**4*MZ**4 + 9*cw**2*MB**2*MW**4*MZ**4 - 12*MT**2*MW**4*MZ**4 + 6*MW**6*MZ**4 + 80*MB**8*MW**2*sw**2 - 160*MB**6*MT**2*MW**2*sw**2 + 80*MB**4*MT**4*MW**2*sw**2 - 160*MB**6*MW**4*sw**2 - 160*MB**4*MT**2*MW**4*sw**2 + 80*MB**4*MW**6*sw**2 - 8*MB**4*MW**2*MZ**4*sw**2 + 16*MB**2*MT**2*MW**2*MZ**4*sw**2 - 8*MT**4*MW**2*MZ**4*sw**2 + 16*MB**2*MW**4*MZ**4*sw**2 + 16*MT**2*MW**4*MZ**4*sw**2 - 8*MW**6*MZ**4*sw**2 - 32*MB**8*MW**2*sw**4 + 64*MB**6*MT**2*MW**2*sw**4 - 32*MB**4*MT**4*MW**2*sw**4 + 64*MB**6*MW**4*sw**4 + 64*MB**4*MT**2*MW**4*sw**4 - 32*MB**4*MW**6*sw**4 - 16*MB**6*MW**2*MZ**2*sw**4 + 32*MB**4*MT**2*MW**2*MZ**2*sw**4 - 16*MB**2*MT**4*MW**2*MZ**2*sw**4 + 32*MB**4*MW**4*MZ**2*sw**4 + 32*MB**2*MT**2*MW**4*MZ**2*sw**4 - 16*MB**2*MW**6*MZ**2*sw**4 + 8*MB**4*MW**2*MZ**4*sw**4 - 16*MB**2*MT**2*MW**2*MZ**4*sw**4 + 8*MT**4*MW**2*MZ**4*sw**4 - 16*MB**2*MW**4*MZ**4*sw**4 - 16*MT**2*MW**4*MZ**4*sw**4 + 8*MW**6*MZ**4*sw**4)*reglog((MB**2 + vep*complex(0,-1))/MU_R**2))/(384.*cw**2*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (3*ee**2*(2*MB**2 - MH**2)*reglog((-MH**2 - cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MW**2*cmath.pi**2*sw**2) - (3*ee**2*(2*MB**2 - MH**2)*reglog((-MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MW**2*cmath.pi**2*sw**2) + (3*ee**2*(2*MB**2 - MH**2)*(2*MB**2 - MH**2 + cmath.sqrt(-4*MB**2*MH**2 + MH**4 + MB**2*vep*complex(0,4)))*reglog((-MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2*MB**2 - MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))))/(256.*MB**2*MW**2*cmath.pi**2*sw**2) - (3*ee**2*(2*MB**2 - MH**2)*(-2*MB**2 + MH**2 + cmath.sqrt(-4*MB**2*MH**2 + MH**4 + MB**2*vep*complex(0,4)))*reglog((MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(-2*MB**2 + MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))))/(256.*MB**2*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**6*MT**2 - 3*MB**4*MT**4 + 3*MB**2*MT**6 - MT**8 + 4*MB**6*MW**2 - 5*MB**4*MT**2*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - 3*MB**2*MT**2*MW**4 + 3*MT**4*MW**4 - 5*MT**2*MW**6 + 2*MW**8)*reglog((-MB**2 + MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(2.*MB**2)))/(64.*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**6*MT**2 - 3*MB**4*MT**4 + 3*MB**2*MT**6 - MT**8 + 4*MB**6*MW**2 - 5*MB**4*MT**2*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - 3*MB**2*MT**2*MW**4 + 3*MT**4*MW**4 - 5*MT**2*MW**6 + 2*MW**8)*reglog((-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(2.*MB**2)))/(64.*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**6*MT**2 - 3*MB**4*MT**4 + 3*MB**2*MT**6 - MT**8 + 4*MB**6*MW**2 - 5*MB**4*MT**2*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - 3*MB**2*MT**2*MW**4 + 3*MT**4*MW**4 - 5*MT**2*MW**6 + 2*MW**8)*(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))*reglog((-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))))/(128.*MB**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**6*MT**2 - 3*MB**4*MT**4 + 3*MB**2*MT**6 - MT**8 + 4*MB**6*MW**2 - 5*MB**4*MT**2*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - 3*MB**2*MT**2*MW**4 + 3*MT**4*MW**4 - 5*MT**2*MW**6 + 2*MW**8)*(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))*reglog((MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))))/(128.*MB**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(-12*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 24*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 6*MW**2*MZ**4 - 80*MB**4*MW**2*sw**2 + 8*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2.*MB**2)))/(384.*cw**2*MB**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) + (ee**2*(-12*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 24*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 6*MW**2*MZ**4 - 80*MB**4*MW**2*sw**2 + 8*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2.*MB**2)))/(384.*cw**2*MB**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (ee**2*(-12*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 24*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 6*MW**2*MZ**4 - 80*MB**4*MW**2*sw**2 + 8*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*(2*MB**2 - MZ**2 + cmath.sqrt(-4*MB**2*MZ**2 + MZ**4 + MB**2*vep*complex(0,4)))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2*MB**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MB**4*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) + (ee**2*(-12*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 24*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 6*MW**2*MZ**4 - 80*MB**4*MW**2*sw**2 + 8*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*(-2*MB**2 + MZ**2 + cmath.sqrt(-4*MB**2*MZ**2 + MZ**4 + MB**2*vep*complex(0,4)))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(-2*MB**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MB**4*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2)) )'},
+                                value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0,-(ee**2*(3*MB**2 + 4*MW**2*sw**2))/(192.*MW**2*cmath.pi**2*sw**2)) )',
+                                          0:'( 0 if MB == 0 else recms(CMSParam==1.0,(ee**2*(72*cw**2*MB**4*MT**2 - 27*cw**2*MB**2*MH**2*MT**2 - 27*cw**2*MB**2*MT**4 + 18*cw**2*MT**6 - 72*cw**2*MB**4*MW**2 + 27*cw**2*MB**2*MH**2*MW**2 + 9*MB**2*MT**2*MW**2 + 27*cw**2*MB**2*MT**2*MW**2 - 9*MB**2*MW**4 + 54*cw**2*MB**2*MW**4 - 54*cw**2*MT**2*MW**4 + 36*cw**2*MW**6 - 27*cw**2*MB**2*MT**2*MZ**2 + 27*cw**2*MB**2*MW**2*MZ**2 - 18*MT**2*MW**2*MZ**2 + 18*MW**4*MZ**2 + 84*MB**2*MT**2*MW**2*sw**2 - 32*cw**2*MB**2*MT**2*MW**2*sw**2 - 84*MB**2*MW**4*sw**2 + 32*cw**2*MB**2*MW**4*sw**2 + 24*MT**2*MW**2*MZ**2*sw**2 - 24*MW**4*MZ**2*sw**2 - 36*MB**2*MT**2*MW**2*sw**4 + 36*MB**2*MW**4*sw**4 - 24*MT**2*MW**2*MZ**2*sw**4 + 24*MW**4*MZ**2*sw**4 + 9*cw**2*MB**2*MT**4*reglog(16.) + 9*MB**2*MT**2*MW**2*reglog(16.) + 9*cw**2*MB**2*MT**2*MW**2*reglog(16.) - 9*MB**2*MW**4*reglog(16.) - 18*cw**2*MB**2*MW**4*reglog(16.) - 12*MB**2*MT**2*MW**2*sw**2*reglog(16.) - 16*cw**2*MB**2*MT**2*MW**2*sw**2*reglog(16.) + 12*MB**2*MW**4*sw**2*reglog(16.) + 16*cw**2*MB**2*MW**4*sw**2*reglog(16.) + 4*MB**2*MT**2*MW**2*sw**4*reglog(16.) - 4*MB**2*MW**4*sw**4*reglog(16.) + 4*cw**2*MB**2*MT**2*MW**2*sw**2*reglog(256.) - 4*cw**2*MB**2*MW**4*sw**2*reglog(256.) + 18*cw**2*MB**4*MT**2*reglog(1/(4.*cmath.pi)) - 18*cw**2*MB**4*MW**2*reglog(1/(4.*cmath.pi)) + 18*MB**2*MT**2*MW**2*reglog(1/(4.*cmath.pi)) - 18*MB**2*MW**4*reglog(1/(4.*cmath.pi)) - 24*MB**2*MT**2*MW**2*sw**2*reglog(1/(4.*cmath.pi)) + 24*MB**2*MW**4*sw**2*reglog(1/(4.*cmath.pi)) + 8*MB**2*MT**2*MW**2*sw**4*reglog(1/(4.*cmath.pi)) - 8*MB**2*MW**4*sw**4*reglog(1/(4.*cmath.pi)) + 18*cw**2*MB**2*MT**4*reglog(cmath.pi) + 18*MB**2*MT**2*MW**2*reglog(cmath.pi) + 54*cw**2*MB**2*MT**2*MW**2*reglog(cmath.pi) - 18*MB**2*MW**4*reglog(cmath.pi) - 72*cw**2*MB**2*MW**4*reglog(cmath.pi) - 24*MB**2*MT**2*MW**2*sw**2*reglog(cmath.pi) - 8*cw**2*MB**2*MT**2*MW**2*sw**2*reglog(cmath.pi) + 24*MB**2*MW**4*sw**2*reglog(cmath.pi) + 8*cw**2*MB**2*MW**4*sw**2*reglog(cmath.pi) + 8*MB**2*MT**2*MW**2*sw**4*reglog(cmath.pi) - 8*MB**2*MW**4*sw**4*reglog(cmath.pi) - 72*cw**2*MB**2*MT**2*MW**2*reglog(2*cmath.pi) + 72*cw**2*MB**2*MW**4*reglog(2*cmath.pi) - 16*cw**2*MB**2*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 16*cw**2*MB**2*MW**4*sw**2*reglog(2*cmath.pi) + 18*cw**2*MB**4*MT**2*reglog(4*cmath.pi) - 18*cw**2*MB**2*MT**4*reglog(4*cmath.pi) - 18*cw**2*MB**4*MW**2*reglog(4*cmath.pi) + 18*cw**2*MB**2*MT**2*MW**2*reglog(4*cmath.pi) + 24*cw**2*MB**2*MT**2*MW**2*sw**2*reglog(4*cmath.pi) - 24*cw**2*MB**2*MW**4*sw**2*reglog(4*cmath.pi)))/(1152.*cw**2*MB**2*(MT - MW)*MW**2*(MT + MW)*cmath.pi**2*sw**2) - (ee**2*(24*cw**2*MB**4 + 6*MB**2*MW**2 - 9*cw**2*MB**2*MZ**2 - 3*MW**2*MZ**2 + 8*MB**2*MW**2*sw**2 + 16*cw**2*MB**2*MW**2*sw**2 + 4*MW**2*MZ**2*sw**2 - 4*cw**2*MW**2*MZ**2*sw**2 - 4*MW**2*MZ**2*sw**4)*(-reglog(MB**2/MU_R**2)))/(192.*cw**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (ee**2*(4*MB**2 - 3*MH**2)*reglog(MU_R**2/MH**2))/(128.*MW**2*cmath.pi**2*sw**2) + (ee**2*MT**2*(MB**6*MT**4 - 3*MB**4*MT**6 + 3*MB**2*MT**8 - MT**10 + 2*MB**6*MT**2*MW**2 - 4*MB**2*MT**6*MW**2 + 2*MT**8*MW**2 - 13*MB**4*MT**2*MW**4 - 3*MB**2*MT**4*MW**4 + 2*MT**6*MW**4 + 4*MB**4*MW**6 + 6*MB**2*MT**2*MW**6 - 8*MT**4*MW**6 - 2*MB**2*MW**8 + 7*MT**2*MW**8 - 2*MW**10)*reglog(MU_R**2/MT**2))/(64.*MB**2*(MB - MT - MW)*(MT - MW)**2*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MT + MW)**2*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(-(MB**4*MT**6) + 2*MB**2*MT**8 - MT**10 + 7*MB**6*MT**2*MW**2 - 14*MB**4*MT**4*MW**2 - 3*MB**2*MT**6*MW**2 + 2*MT**8*MW**2 - 4*MB**6*MW**4 - 3*MB**4*MT**2*MW**4 + 2*MT**6*MW**4 + 6*MB**4*MW**6 + MB**2*MT**2*MW**6 - 8*MT**4*MW**6 + 7*MT**2*MW**8 - 2*MW**10)*reglog(MU_R**2/MW**2))/(64.*MB**2*(MB - MT - MW)*(MT - MW)**2*(MB + MT - MW)*(MB - MT + MW)*(MT + MW)**2*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(24*cw**2*MB**4*MZ**2 + 18*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 6*MW**2*MZ**4 - 64*MB**4*MW**2*sw**2 + 8*MB**2*MW**2*MZ**2*sw**2 + 8*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 8*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*reglog(MU_R**2/MZ**2))/(384.*cw**2*MB**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (ee**2*(72*cw**2*MB**10 - 36*cw**2*MB**8*MH**2 - 168*cw**2*MB**8*MT**2 + 72*cw**2*MB**6*MH**2*MT**2 + 144*cw**2*MB**6*MT**4 - 36*cw**2*MB**4*MH**2*MT**4 - 72*cw**2*MB**4*MT**6 + 24*cw**2*MB**2*MT**8 + 12*MB**8*MW**2 - 240*cw**2*MB**8*MW**2 + 72*cw**2*MB**6*MH**2*MW**2 - 24*MB**6*MT**2*MW**2 - 24*cw**2*MB**6*MT**2*MW**2 + 72*cw**2*MB**4*MH**2*MT**2*MW**2 + 12*MB**4*MT**4*MW**2 - 24*cw**2*MB**2*MT**6*MW**2 - 24*MB**6*MW**4 + 216*cw**2*MB**6*MW**4 - 36*cw**2*MB**4*MH**2*MW**4 - 24*MB**4*MT**2*MW**4 + 72*cw**2*MB**4*MT**2*MW**4 - 72*cw**2*MB**2*MT**4*MW**4 + 12*MB**4*MW**6 + 120*cw**2*MB**2*MT**2*MW**6 - 48*cw**2*MB**2*MW**8 - 48*cw**2*MB**8*MZ**2 + 9*cw**2*MB**6*MH**2*MZ**2 + 102*cw**2*MB**6*MT**2*MZ**2 - 18*cw**2*MB**4*MH**2*MT**2*MZ**2 - 66*cw**2*MB**4*MT**4*MZ**2 + 9*cw**2*MB**2*MH**2*MT**4*MZ**2 + 18*cw**2*MB**2*MT**6*MZ**2 - 6*cw**2*MT**8*MZ**2 - 24*MB**6*MW**2*MZ**2 + 120*cw**2*MB**6*MW**2*MZ**2 - 18*cw**2*MB**4*MH**2*MW**2*MZ**2 + 48*MB**4*MT**2*MW**2*MZ**2 + 66*cw**2*MB**4*MT**2*MW**2*MZ**2 - 18*cw**2*MB**2*MH**2*MT**2*MW**2*MZ**2 - 24*MB**2*MT**4*MW**2*MZ**2 + 6*cw**2*MT**6*MW**2*MZ**2 + 48*MB**4*MW**4*MZ**2 - 84*cw**2*MB**4*MW**4*MZ**2 + 9*cw**2*MB**2*MH**2*MW**4*MZ**2 + 48*MB**2*MT**2*MW**4*MZ**2 - 18*cw**2*MB**2*MT**2*MW**4*MZ**2 + 18*cw**2*MT**4*MW**4*MZ**2 - 24*MB**2*MW**6*MZ**2 - 30*cw**2*MT**2*MW**6*MZ**2 + 12*cw**2*MW**8*MZ**2 + 9*cw**2*MB**6*MZ**4 - 18*cw**2*MB**4*MT**2*MZ**4 + 9*cw**2*MB**2*MT**4*MZ**4 + 6*MB**4*MW**2*MZ**4 - 18*cw**2*MB**4*MW**2*MZ**4 - 12*MB**2*MT**2*MW**2*MZ**4 - 18*cw**2*MB**2*MT**2*MW**2*MZ**4 + 6*MT**4*MW**2*MZ**4 - 12*MB**2*MW**4*MZ**4 + 9*cw**2*MB**2*MW**4*MZ**4 - 12*MT**2*MW**4*MZ**4 + 6*MW**6*MZ**4 + 80*MB**8*MW**2*sw**2 - 160*MB**6*MT**2*MW**2*sw**2 + 80*MB**4*MT**4*MW**2*sw**2 - 160*MB**6*MW**4*sw**2 - 160*MB**4*MT**2*MW**4*sw**2 + 80*MB**4*MW**6*sw**2 - 8*MB**4*MW**2*MZ**4*sw**2 + 16*MB**2*MT**2*MW**2*MZ**4*sw**2 - 8*MT**4*MW**2*MZ**4*sw**2 + 16*MB**2*MW**4*MZ**4*sw**2 + 16*MT**2*MW**4*MZ**4*sw**2 - 8*MW**6*MZ**4*sw**2 - 32*MB**8*MW**2*sw**4 + 64*MB**6*MT**2*MW**2*sw**4 - 32*MB**4*MT**4*MW**2*sw**4 + 64*MB**6*MW**4*sw**4 + 64*MB**4*MT**2*MW**4*sw**4 - 32*MB**4*MW**6*sw**4 - 16*MB**6*MW**2*MZ**2*sw**4 + 32*MB**4*MT**2*MW**2*MZ**2*sw**4 - 16*MB**2*MT**4*MW**2*MZ**2*sw**4 + 32*MB**4*MW**4*MZ**2*sw**4 + 32*MB**2*MT**2*MW**4*MZ**2*sw**4 - 16*MB**2*MW**6*MZ**2*sw**4 + 8*MB**4*MW**2*MZ**4*sw**4 - 16*MB**2*MT**2*MW**2*MZ**4*sw**4 + 8*MT**4*MW**2*MZ**4*sw**4 - 16*MB**2*MW**4*MZ**4*sw**4 - 16*MT**2*MW**4*MZ**4*sw**4 + 8*MW**6*MZ**4*sw**4)*reglog((MB**2 + vep*complex(0,-1))/MU_R**2))/(384.*cw**2*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (3*ee**2*(2*MB**2 - MH**2)*reglogm((-MH**2 - cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MW**2*cmath.pi**2*sw**2) - (3*ee**2*(2*MB**2 - MH**2)*reglogm((-MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2.*MB**2)))/(128.*MW**2*cmath.pi**2*sw**2) + (3*ee**2*(2*MB**2 - MH**2)*(2*MB**2 - MH**2 + cmath.sqrt(-4*MB**2*MH**2 + MH**4 + MB**2*vep*complex(0,4)))*reglogm((-MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(2*MB**2 - MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))))/(256.*MB**2*MW**2*cmath.pi**2*sw**2) - (3*ee**2*(2*MB**2 - MH**2)*(-2*MB**2 + MH**2 + cmath.sqrt(-4*MB**2*MH**2 + MH**4 + MB**2*vep*complex(0,4)))*reglogm((MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))/(-2*MB**2 + MH**2 + cmath.sqrt(MH**4 - 4*MB**2*(MH**2 + vep*complex(0,-1))))))/(256.*MB**2*MW**2*cmath.pi**2*sw**2) + (ee**2*(MB**6*MT**2 - 3*MB**4*MT**4 + 3*MB**2*MT**6 - MT**8 + 4*MB**6*MW**2 - 5*MB**4*MT**2*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - 3*MB**2*MT**2*MW**4 + 3*MT**4*MW**4 - 5*MT**2*MW**6 + 2*MW**8)*reglogm((-MB**2 + MT**2 - MW**2 - cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(2.*MB**2)))/(64.*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**6*MT**2 - 3*MB**4*MT**4 + 3*MB**2*MT**6 - MT**8 + 4*MB**6*MW**2 - 5*MB**4*MT**2*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - 3*MB**2*MT**2*MW**4 + 3*MT**4*MW**4 - 5*MT**2*MW**6 + 2*MW**8)*reglogm((-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(2.*MB**2)))/(64.*MB**2*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**6*MT**2 - 3*MB**4*MT**4 + 3*MB**2*MT**6 - MT**8 + 4*MB**6*MW**2 - 5*MB**4*MT**2*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - 3*MB**2*MT**2*MW**4 + 3*MT**4*MW**4 - 5*MT**2*MW**6 + 2*MW**8)*(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))*reglogm((-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))))/(128.*MB**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**6*MT**2 - 3*MB**4*MT**4 + 3*MB**2*MT**6 - MT**8 + 4*MB**6*MW**2 - 5*MB**4*MT**2*MW**2 + MT**6*MW**2 - 6*MB**4*MW**4 - 3*MB**2*MT**2*MW**4 + 3*MT**4*MW**4 - 5*MT**2*MW**6 + 2*MW**8)*(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))*reglogm((MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))/(-MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 + MT**2 - MW**2)**2 - 4*MB**2*(MT**2 + vep*complex(0,-1))))))/(128.*MB**4*(MB - MT - MW)*(MB + MT - MW)*MW**2*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(-12*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 24*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 6*MW**2*MZ**4 - 80*MB**4*MW**2*sw**2 + 8*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*reglogm((-MZ**2 - cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2.*MB**2)))/(384.*cw**2*MB**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) + (ee**2*(-12*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 24*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 6*MW**2*MZ**4 - 80*MB**4*MW**2*sw**2 + 8*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*reglogm((-MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2.*MB**2)))/(384.*cw**2*MB**2*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) - (ee**2*(-12*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 24*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 6*MW**2*MZ**4 - 80*MB**4*MW**2*sw**2 + 8*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*(2*MB**2 - MZ**2 + cmath.sqrt(-4*MB**2*MZ**2 + MZ**4 + MB**2*vep*complex(0,4)))*reglogm((-MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(2*MB**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MB**4*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2) + (ee**2*(-12*MB**4*MW**2 + 30*cw**2*MB**4*MZ**2 + 24*MB**2*MW**2*MZ**2 - 9*cw**2*MB**2*MZ**4 - 6*MW**2*MZ**4 - 80*MB**4*MW**2*sw**2 + 8*MW**2*MZ**4*sw**2 + 32*MB**4*MW**2*sw**4 + 16*MB**2*MW**2*MZ**2*sw**4 - 8*MW**2*MZ**4*sw**4)*(-2*MB**2 + MZ**2 + cmath.sqrt(-4*MB**2*MZ**2 + MZ**4 + MB**2*vep*complex(0,4)))*reglogm((MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))/(-2*MB**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MB**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MB**4*MW**2*(2*MB - MZ)*(2*MB + MZ)*cmath.pi**2*sw**2)) )'},
                                 texname = '\delta ZL_b^{EW,MB}')
 
 dMB_HWcft_UV_EW = CTParameter(name = 'dMB_HWcft_UV_EW',
                               type = 'complex',
-                              value = {-1:'( 0 if MB == 0 else re(-(ee**2*MB**2*Ncol)/(32.*MW**2*cmath.pi**2*sw**2)) )',
-                                        0:'( 0 if MB == 0 else re((ee**2*MB**2*Ncol*((-8*MB**2)/MH**2 + 2*reglog(4*cmath.pi) - 2*(1 + reglog(4*cmath.pi)) + (4*MB**2*reglog(MU_R**2/MB**2))/MH**2 + (2*(2*MB**2 + MH**2)*reglog((MH**2 + vep*complex(0,-1))/MU_R**2))/MH**2 + (2*(2*MB**2 + MH**2)*reglog((-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(2.*MH**2)))/MH**2 - ((2*MB**2 + MH**2)*(MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))))/MH**4 + (2*(2*MB**2 + MH**2)*reglog(-(MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(2.*MH**2)))/MH**2 + ((2*MB**2 + MH**2)*(-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))))/MH**4))/(64.*MW**2*cmath.pi**2*sw**2)) )'},
+                              value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0 and WH != 0,-(ee**2*MB**2*Ncol)/(32.*MW**2*cmath.pi**2*sw**2)) )',
+                                        0:'( 0 if MB == 0 else recms(CMSParam==1.0 and WH != 0,(ee**2*MB**2*Ncol*((-8*MB**2)/MH**2 + 2*reglog(4*cmath.pi) - 2*(1 + reglog(4*cmath.pi)) + (4*MB**2*(-reglog(MB**2/MU_R**2)))/MH**2 + (2*(2*MB**2 + MH**2)*reglog((MH**2 + vep*complex(0,-1))/MU_R**2))/MH**2 + (2*(2*MB**2 + MH**2)*reglogm((-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(2.*MH**2)))/MH**2 - ((2*MB**2 + MH**2)*(MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))*reglogm((-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))))/MH**4 + (2*(2*MB**2 + MH**2)*reglogm(-(MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(2.*MH**2)))/MH**2 + ((2*MB**2 + MH**2)*(-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))*reglogm((MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(-4*MB**2 + MH**2 + vep*complex(0,4))))))/MH**4))/(64.*MW**2*cmath.pi**2*sw**2)) )'},
                               texname = '\delta Z_{H}^{EW,MB}')
 
 
 dMB_G0Wcft_UV_EW = CTParameter(name = 'dMB_G0Wcft_UV_EW',
                                type = 'complex',
-                               value = {-1:'( 0 if MB == 0 else re(-(ee**2*MB**2*Ncol)/(32.*MW**2*cmath.pi**2*sw**2)) )',
-                                         0:'( 0 if MB == 0 else re((ee**2*MB**2*Ncol*(-reglog(16.) - 2*(1 + reglog(cmath.pi)) + 2*reglog(4*cmath.pi) - (4*MB**2*reglog(MU_R**2/MB**2))/(4*MB**2 - MZ**2) + (2*(-2*MB**2 + MZ**2)*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/(-4*MB**2 + MZ**2) + (2*(2*MB**2 - MZ**2)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MB**2 - MZ**2) + ((-2*MB**2 + MZ**2)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/(4*MB**2*MZ**2 - MZ**4) + (2*(2*MB**2 - MZ**2)*reglog(-(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MB**2 - MZ**2) + ((-2*MB**2 + MZ**2)*(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/(-4*MB**2*MZ**2 + MZ**4)))/(64.*MW**2*cmath.pi**2*sw**2)) )'},
+                               value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0 and WZ != 0,-(ee**2*MB**2*Ncol)/(32.*MW**2*cmath.pi**2*sw**2)) )',
+                                         0:'( 0 if MB == 0 else recms(CMSParam==1.0 and WZ != 0,(ee**2*MB**2*Ncol*(-reglog(16.) - 2*(1 + reglog(cmath.pi)) + 2*reglog(4*cmath.pi) - (4*MB**2*(-reglog(MB**2/MU_R**2)))/(4*MB**2 - MZ**2) + (2*(-2*MB**2 + MZ**2)*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/(-4*MB**2 + MZ**2) + (2*(2*MB**2 - MZ**2)*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MB**2 - MZ**2) + ((-2*MB**2 + MZ**2)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/(4*MB**2*MZ**2 - MZ**4) + (2*(2*MB**2 - MZ**2)*reglogm(-(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MB**2 - MZ**2) + ((-2*MB**2 + MZ**2)*(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/(-4*MB**2*MZ**2 + MZ**4)))/(64.*MW**2*cmath.pi**2*sw**2)) )'},
                                texname = '\delta Z_{G0}^{EW,MB}')
 
 
 dMB_GpWcft_UV_EW = CTParameter(name = 'dMB_GpWcft_UV_EW',
                                type = 'complex',
-                               value = {-1:'( 0 if MB == 0 else re(-(ee**2*MB**2*Ncol)/(32.*MW**2*cmath.pi**2*sw**2)) )',
-                                         0:'( 0 if MB == 0 else re((ee**2*MB**2*Ncol*reglog(4*cmath.pi))/(32.*MW**2*cmath.pi**2*sw**2) + (ee**2*Ncol*(-(MB**2*MW**2*(2*MB**2 - 4*MT**2 + MW**2*(2 + reglog(16.) + 2*reglog(cmath.pi)))) + (2*MB**2*MW**2*(MB**2 - MT**2 - MW**2)*(MB**4 + MT**4 - MT**2*MW**2 - MB**2*(2*MT**2 + MW**2))*reglog(MU_R**2/MB**2))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)) + (2*MT**2*MW**2*(-MB**2 + MT**2 + MW**2)*(MB**4 - 2*MB**2*MT**2 + (MT**2 - MW**2)**2)*reglog(MU_R**2/MT**2))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)) + 2*MT**2*(MT - MW)*(MT + MW)*(MT**2 + MW**2)*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2) + (2*MW**2*(MB**8 - MB**6*(4*MT**2 + MW**2) + (MT**2 + MW**2)*(MT**3 - MT*MW**2)**2 + MB**4*(6*MT**4 + MT**2*MW**2 - MW**4) + MB**2*(-4*MT**6 + MT**4*MW**2 - 2*MT**2*MW**4 + MW**6))*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)) + (2*MW**2*(MB**8 - MB**6*(4*MT**2 + MW**2) + (MT**2 + MW**2)*(MT**3 - MT*MW**2)**2 + MB**4*(6*MT**4 + MT**2*MW**2 - MW**4) + MB**2*(-4*MT**6 + MT**4*MW**2 - 2*MT**2*MW**4 + MW**6))*reglog((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)) + (2*MW**2*(MB**8 - MB**6*(4*MT**2 + MW**2) + (MT**2 + MW**2)*(MT**3 - MT*MW**2)**2 + MB**4*(6*MT**4 + MT**2*MW**2 - MW**4) + MB**2*(-4*MT**6 + MT**4*MW**2 - 2*MT**2*MW**4 + MW**6))*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)) - ((MB**8 - MB**6*(4*MT**2 + MW**2) + (MT**2 + MW**2)*(MT**3 - MT*MW**2)**2 + MB**4*(6*MT**4 + MT**2*MW**2 - MW**4) + MB**2*(-4*MT**6 + MT**4*MW**2 - 2*MT**2*MW**4 + MW**6))*(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)) + ((MB**8 - MB**6*(4*MT**2 + MW**2) + (MT**2 + MW**2)*(MT**3 - MT*MW**2)**2 + MB**4*(6*MT**4 + MT**2*MW**2 - MW**4) + MB**2*(-4*MT**6 + MT**4*MW**2 - 2*MT**2*MW**4 + MW**6))*(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglog((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW))))/(64.*MW**6*cmath.pi**2*sw**2)) )'},
+                               value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0 and WW != 0,-(ee**2*MB**2*Ncol)/(32.*MW**2*cmath.pi**2*sw**2)) )',
+                                         0:'( 0 if MB == 0 else recms(CMSParam==1.0 and WW != 0,(ee**2*MB**2*Ncol*reglog(4*cmath.pi))/(32.*MW**2*cmath.pi**2*sw**2) + (ee**2*Ncol*(-(MB**2*MW**2*(2*MB**2 - 4*MT**2 + MW**2*(2 + reglog(16.) + 2*reglog(cmath.pi)))) + (2*MB**2*MW**2*(MB**2 - MT**2 - MW**2)*(MB**4 + MT**4 - MT**2*MW**2 - MB**2*(2*MT**2 + MW**2))*(-reglog(MB**2/MU_R**2)))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)) + (2*MT**2*MW**2*(-MB**2 + MT**2 + MW**2)*(MB**4 - 2*MB**2*MT**2 + (MT**2 - MW**2)**2)*reglog(MU_R**2/MT**2))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)) + 2*MT**2*(MT - MW)*(MT + MW)*(MT**2 + MW**2)*reglogm((MT**2 - MW**2 + vep*complex(0,-1))/MT**2) + (2*MW**2*(MB**8 - MB**6*(4*MT**2 + MW**2) + (MT**2 + MW**2)*(MT**3 - MT*MW**2)**2 + MB**4*(6*MT**4 + MT**2*MW**2 - MW**4) + MB**2*(-4*MT**6 + MT**4*MW**2 - 2*MT**2*MW**4 + MW**6))*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)) + (2*MW**2*(MB**8 - MB**6*(4*MT**2 + MW**2) + (MT**2 + MW**2)*(MT**3 - MT*MW**2)**2 + MB**4*(6*MT**4 + MT**2*MW**2 - MW**4) + MB**2*(-4*MT**6 + MT**4*MW**2 - 2*MT**2*MW**4 + MW**6))*reglogm((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)) + (2*MW**2*(MB**8 - MB**6*(4*MT**2 + MW**2) + (MT**2 + MW**2)*(MT**3 - MT*MW**2)**2 + MB**4*(6*MT**4 + MT**2*MW**2 - MW**4) + MB**2*(-4*MT**6 + MT**4*MW**2 - 2*MT**2*MW**4 + MW**6))*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)) - ((MB**8 - MB**6*(4*MT**2 + MW**2) + (MT**2 + MW**2)*(MT**3 - MT*MW**2)**2 + MB**4*(6*MT**4 + MT**2*MW**2 - MW**4) + MB**2*(-4*MT**6 + MT**4*MW**2 - 2*MT**2*MW**4 + MW**6))*(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW)) + ((MB**8 - MB**6*(4*MT**2 + MW**2) + (MT**2 + MW**2)*(MT**3 - MT*MW**2)**2 + MB**4*(6*MT**4 + MT**2*MW**2 - MW**4) + MB**2*(-4*MT**6 + MT**4*MW**2 - 2*MT**2*MW**4 + MW**6))*(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglogm((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))))/((MB - MT - MW)*(MB + MT - MW)*(MB - MT + MW)*(MB + MT + MW))))/(64.*MW**6*cmath.pi**2*sw**2)) )'},
                                texname = '\delta Z_{Gp}^{EW,MB}')
 
 dMB_WWcft_UV_EW = CTParameter(name = 'dMB_WWcft_UV_EW',
                               type = 'complex',
-                              value = {0:'( 0 if MB == 0 else re(-(ee**2*MB**2*(2*MB**2 - 4*MT**2 + MW**2)*Ncol)/(96.*MW**4*cmath.pi**2*sw**2) + (ee**2*MB**2*(MB**2 - MT**2 - MT*MW - MW**2)*(MB**2 - MT**2 + MT*MW - MW**2)*(MB**2 - MT**2 + MW**2)*Ncol*reglog(MU_R**2/MB**2))/(48.*(MB - MT - MW)*(MB + MT - MW)*MW**4*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**6*MT**2 - 3*MB**4*MT**4 + 3*MB**2*MT**6 - MT**8 - MB**2*MT**4*MW**2 + MT**6*MW**2 - MB**4*MW**4 + 2*MB**2*MT**2*MW**4 + 2*MB**2*MW**6 + MT**2*MW**6 - MW**8)*Ncol*reglog(MU_R**2/MT**2))/(48.*(MB - MT - MW)*(MB + MT - MW)*MW**4*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(-MT + MW)*(MT + MW)*(MT**2 - MT*MW + MW**2)*(MT**2 + MT*MW + MW**2)*Ncol*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2))/(48.*MW**6*cmath.pi**2*sw**2) + (ee**2*(MB**8 - 4*MB**6*MT**2 + 6*MB**4*MT**4 - 4*MB**2*MT**6 + MT**8 - MB**6*MW**2 + MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 - MT**6*MW**2 - 2*MB**2*MT**2*MW**4 - MB**2*MW**6 - MT**2*MW**6 + MW**8)*Ncol*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/(48.*(MB - MT - MW)*(MB + MT - MW)*MW**4*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**8 - 4*MB**6*MT**2 + 6*MB**4*MT**4 - 4*MB**2*MT**6 + MT**8 - MB**6*MW**2 + MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 - MT**6*MW**2 - 2*MB**2*MT**2*MW**4 - MB**2*MW**6 - MT**2*MW**6 + MW**8)*Ncol*reglog((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)))/(48.*(MB - MT - MW)*(MB + MT - MW)*MW**4*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**8 - 4*MB**6*MT**2 + 6*MB**4*MT**4 - 4*MB**2*MT**6 + MT**8 - MB**6*MW**2 + MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 - MT**6*MW**2 - 2*MB**2*MT**2*MW**4 - MB**2*MW**6 - MT**2*MW**6 + MW**8)*Ncol*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)))/(48.*(MB - MT - MW)*(MB + MT - MW)*MW**4*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**8 - 4*MB**6*MT**2 + 6*MB**4*MT**4 - 4*MB**2*MT**6 + MT**8 - MB**6*MW**2 + MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 - MT**6*MW**2 - 2*MB**2*MT**2*MW**4 - MB**2*MW**6 - MT**2*MW**6 + MW**8)*Ncol*(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))))/(96.*(MB - MT - MW)*(MB + MT - MW)*MW**6*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**8 - 4*MB**6*MT**2 + 6*MB**4*MT**4 - 4*MB**2*MT**6 + MT**8 - MB**6*MW**2 + MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 - MT**6*MW**2 - 2*MB**2*MT**2*MW**4 - MB**2*MW**6 - MT**2*MW**6 + MW**8)*Ncol*(MB**2 - MT**2 + MW**2 - cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglog((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))))/(96.*(MB - MT - MW)*(MB + MT - MW)*MW**6*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2)) )'},
+                              value = {0:'( 0 if MB == 0 else recms(CMSParam==1.0 and WW != 0,-(ee**2*MB**2*(2*MB**2 - 4*MT**2 + MW**2)*Ncol)/(96.*MW**4*cmath.pi**2*sw**2) + (ee**2*MB**2*(MB**2 - MT**2 - MT*MW - MW**2)*(MB**2 - MT**2 + MT*MW - MW**2)*(MB**2 - MT**2 + MW**2)*Ncol*(-reglog(MB**2/MU_R**2)))/(48.*(MB - MT - MW)*(MB + MT - MW)*MW**4*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**6*MT**2 - 3*MB**4*MT**4 + 3*MB**2*MT**6 - MT**8 - MB**2*MT**4*MW**2 + MT**6*MW**2 - MB**4*MW**4 + 2*MB**2*MT**2*MW**4 + 2*MB**2*MW**6 + MT**2*MW**6 - MW**8)*Ncol*reglog(MU_R**2/MT**2))/(48.*(MB - MT - MW)*(MB + MT - MW)*MW**4*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(-MT + MW)*(MT + MW)*(MT**2 - MT*MW + MW**2)*(MT**2 + MT*MW + MW**2)*Ncol*reglogm((MT**2 - MW**2 + vep*complex(0,-1))/MT**2))/(48.*MW**6*cmath.pi**2*sw**2) + (ee**2*(MB**8 - 4*MB**6*MT**2 + 6*MB**4*MT**4 - 4*MB**2*MT**6 + MT**8 - MB**6*MW**2 + MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 - MT**6*MW**2 - 2*MB**2*MT**2*MW**4 - MB**2*MW**6 - MT**2*MW**6 + MW**8)*Ncol*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/(48.*(MB - MT - MW)*(MB + MT - MW)*MW**4*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**8 - 4*MB**6*MT**2 + 6*MB**4*MT**4 - 4*MB**2*MT**6 + MT**8 - MB**6*MW**2 + MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 - MT**6*MW**2 - 2*MB**2*MT**2*MW**4 - MB**2*MW**6 - MT**2*MW**6 + MW**8)*Ncol*reglogm((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)))/(48.*(MB - MT - MW)*(MB + MT - MW)*MW**4*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) + (ee**2*(MB**8 - 4*MB**6*MT**2 + 6*MB**4*MT**4 - 4*MB**2*MT**6 + MT**8 - MB**6*MW**2 + MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 - MT**6*MW**2 - 2*MB**2*MT**2*MW**4 - MB**2*MW**6 - MT**2*MW**6 + MW**8)*Ncol*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)))/(48.*(MB - MT - MW)*(MB + MT - MW)*MW**4*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**8 - 4*MB**6*MT**2 + 6*MB**4*MT**4 - 4*MB**2*MT**6 + MT**8 - MB**6*MW**2 + MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 - MT**6*MW**2 - 2*MB**2*MT**2*MW**4 - MB**2*MW**6 - MT**2*MW**6 + MW**8)*Ncol*(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))))/(96.*(MB - MT - MW)*(MB + MT - MW)*MW**6*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2) - (ee**2*(MB**8 - 4*MB**6*MT**2 + 6*MB**4*MT**4 - 4*MB**2*MT**6 + MT**8 - MB**6*MW**2 + MB**4*MT**2*MW**2 + MB**2*MT**4*MW**2 - MT**6*MW**2 - 2*MB**2*MT**2*MW**4 - MB**2*MW**6 - MT**2*MW**6 + MW**8)*Ncol*(MB**2 - MT**2 + MW**2 - cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglogm((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))))/(96.*(MB - MT - MW)*(MB + MT - MW)*MW**6*(MB - MT + MW)*(MB + MT + MW)*cmath.pi**2*sw**2)) )'},
                               texname = '\delta Z_{W}^{EW,MB}')
 
 dMB_ZZWcft_UV_EW = CTParameter(name = 'dMB_ZZWcft_UV_EW',
                                type = 'complex',
-                               value = {                                         0:'( 0 if MB == 0 else re((ee**2*Ncol*((2*MB**2*(-9 - 24*sw**2 + 16*sw**4))/MZ**2 - (4*MB**2*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog(MU_R**2/MB**2))/(4*MB**2*MZ**2 - MZ**4) - (2*(-2*MB**2*MZ**2*(9 - 12*sw**2 + 8*sw**4) + MZ**4*(9 - 12*sw**2 + 8*sw**4) + 2*MB**4*(-9 - 24*sw**2 + 16*sw**4))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/(4*MB**2*MZ**2 - MZ**4) + 2*(9 - 12*sw**2 + 8*sw**4)*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - (2*(-2*MB**2*MZ**2*(9 - 12*sw**2 + 8*sw**4) + MZ**4*(9 - 12*sw**2 + 8*sw**4) + 2*MB**4*(-9 - 24*sw**2 + 16*sw**4))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MB**2*MZ**2 - MZ**4) + ((-2*MB**2*MZ**2*(9 - 12*sw**2 + 8*sw**4) + MZ**4*(9 - 12*sw**2 + 8*sw**4) + 2*MB**4*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/(4*MB**2*MZ**4 - MZ**6) - (2*(-2*MB**2*MZ**2*(9 - 12*sw**2 + 8*sw**4) + MZ**4*(9 - 12*sw**2 + 8*sw**4) + 2*MB**4*(-9 - 24*sw**2 + 16*sw**4))*reglog(-(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MB**2*MZ**2 - MZ**4) + ((-2*MB**2*MZ**2*(9 - 12*sw**2 + 8*sw**4) + MZ**4*(9 - 12*sw**2 + 8*sw**4) + 2*MB**4*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/(4*MB**2*MZ**4 - MZ**6)))/(1728.*cw**2*cmath.pi**2*sw**2)) )'},
+                               value = {                                         0:'( 0 if MB == 0 else recms(CMSParam==1.0 and WZ != 0,(ee**2*Ncol*((2*MB**2*(-9 - 24*sw**2 + 16*sw**4))/MZ**2 - (4*MB**2*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(-reglog(MB**2/MU_R**2)))/(4*MB**2*MZ**2 - MZ**4) - (2*(-2*MB**2*MZ**2*(9 - 12*sw**2 + 8*sw**4) + MZ**4*(9 - 12*sw**2 + 8*sw**4) + 2*MB**4*(-9 - 24*sw**2 + 16*sw**4))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/(4*MB**2*MZ**2 - MZ**4) + 2*(9 - 12*sw**2 + 8*sw**4)*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - (2*(-2*MB**2*MZ**2*(9 - 12*sw**2 + 8*sw**4) + MZ**4*(9 - 12*sw**2 + 8*sw**4) + 2*MB**4*(-9 - 24*sw**2 + 16*sw**4))*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MB**2*MZ**2 - MZ**4) + ((-2*MB**2*MZ**2*(9 - 12*sw**2 + 8*sw**4) + MZ**4*(9 - 12*sw**2 + 8*sw**4) + 2*MB**4*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/(4*MB**2*MZ**4 - MZ**6) - (2*(-2*MB**2*MZ**2*(9 - 12*sw**2 + 8*sw**4) + MZ**4*(9 - 12*sw**2 + 8*sw**4) + 2*MB**4*(-9 - 24*sw**2 + 16*sw**4))*reglogm(-(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MB**2*MZ**2 - MZ**4) + ((-2*MB**2*MZ**2*(9 - 12*sw**2 + 8*sw**4) + MZ**4*(9 - 12*sw**2 + 8*sw**4) + 2*MB**4*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/(4*MB**2*MZ**4 - MZ**6)))/(1728.*cw**2*cmath.pi**2*sw**2)) )'},
                                texname = '\delta Z_{ZZ}^{EW,MB}')
 
 
 dMB_AZWcft_UV_EW = CTParameter(name = 'dMB_AZWcft_UV_EW',
                                type = 'complex',
-                               value = {                                         0:'( 0 if MB == 0 else re((ee**2*((16*MB**2*Ncol*(3 - 4*sw**2))/MZ**2 + (8*MB**2*Ncol*(-3 + 4*sw**2)*reglog(MU_R**2/MB**2))/MZ**2 + (4*(2*MB**2 + MZ**2)*Ncol*(-3 + 4*sw**2)*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/MZ**2 - 4*(-27 - 18*Ncol + 108*sw**2 + 40*Ncol*sw**2)*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) + 4*(-27 - 21*Ncol + 108*sw**2 + 44*Ncol*sw**2)*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) + (4*(2*MB**2 + MZ**2)*Ncol*(-3 + 4*sw**2)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 - (2*(2*MB**2 + MZ**2)*Ncol*(-3 + 4*sw**2)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**4 + (4*(2*MB**2 + MZ**2)*Ncol*(-3 + 4*sw**2)*reglog(-(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 - (2*(2*MB**2 + MZ**2)*Ncol*(-3 + 4*sw**2)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**4))/(864.*cw*cmath.pi**2*sw)) )'},
+                               value = {                                         0:'( 0 if MB == 0 else recms(CMSParam==1.0 and WZ != 0,(ee**2*((16*MB**2*Ncol*(3 - 4*sw**2))/MZ**2 + (8*MB**2*Ncol*(-3 + 4*sw**2)*(-reglog(MB**2/MU_R**2)))/MZ**2 + (4*(2*MB**2 + MZ**2)*Ncol*(-3 + 4*sw**2)*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/MZ**2 - 4*(-27 - 18*Ncol + 108*sw**2 + 40*Ncol*sw**2)*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) + 4*(-27 - 21*Ncol + 108*sw**2 + 44*Ncol*sw**2)*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) + (4*(2*MB**2 + MZ**2)*Ncol*(-3 + 4*sw**2)*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 - (2*(2*MB**2 + MZ**2)*Ncol*(-3 + 4*sw**2)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**4 + (4*(2*MB**2 + MZ**2)*Ncol*(-3 + 4*sw**2)*reglogm(-(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 - (2*(2*MB**2 + MZ**2)*Ncol*(-3 + 4*sw**2)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**4))/(864.*cw*cmath.pi**2*sw)) )'},
                                texname = '\delta Z_{AZ}^{EW,MB}')
 
 
 dMB_AAWcft_UV_EW = CTParameter(name = 'dMB_AAWcft_UV_EW',
                                type = 'complex',
-                               value = {-1:'( 0 if MB == 0 else re(-(ee**2*Ncol)/(108.*cmath.pi**2)) )',
-                                         0:'( 0 if MB == 0 else re((ee**2*Ncol*(reglog(MB) - reglog(MU_R)))/(54.*cmath.pi**2)) )'},
+                               value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0,-(ee**2*Ncol)/(108.*cmath.pi**2)) )',
+                                         0:'( 0 if MB == 0 else recms(CMSParam==1.0,(ee**2*Ncol*(reglog(MB) - reglog(MU_R)))/(54.*cmath.pi**2)) )'},
                                texname = '\delta Z_{AA}^{EW,MB}')
 
 
 dMB_eCoup_UV_EW = CTParameter(name = 'dMB_eCoup_UV_EW',
                               type = 'complex',
-                              value = {                                        0:'( 0 if MB == 0 else re((ee**2*Ncol*(reglog(256.) - 8*reglog(MB) + 4*reglog(cmath.pi) + 8*reglog(MU_R)))/(864.*cmath.pi**2) + (ee**2*(2*Ncol*((12*MB**2)/MZ**2 - reglog(64.) - 3*reglog(cmath.pi)) - (6*(2*MB**2 + MZ**2)*Ncol*reglog(MU_R**2/MB**2))/MZ**2 - (6*(2*MB**2 + MZ**2)*Ncol*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/MZ**2 + 6*(27 + 10*Ncol)*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 6*(27 + 11*Ncol)*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - (6*(2*MB**2 + MZ**2)*Ncol*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 + (3*(2*MB**2 + MZ**2)*Ncol*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**4 - (6*(2*MB**2 + MZ**2)*Ncol*reglog(-(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 + (3*(2*MB**2 + MZ**2)*Ncol*(MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**4))/(1296.*cmath.pi**2)) )'},
+                              value = {                                        0:'( 0 if MB == 0 else recms(CMSParam==1.0,(ee**2*Ncol*(reglog(256.) - 8*reglog(MB) + 4*reglog(cmath.pi) + 8*reglog(MU_R)))/(864.*cmath.pi**2) + (ee**2*(2*Ncol*((12*MB**2)/MZ**2 - reglog(64.) - 3*reglog(cmath.pi)) - (6*(2*MB**2 + MZ**2)*Ncol*(-reglog(MB**2/MU_R**2)))/MZ**2 - (6*(2*MB**2 + MZ**2)*Ncol*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/MZ**2 + 6*(27 + 10*Ncol)*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 6*(27 + 11*Ncol)*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - (6*(2*MB**2 + MZ**2)*Ncol*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 + (3*(2*MB**2 + MZ**2)*Ncol*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**4 - (6*(2*MB**2 + MZ**2)*Ncol*reglogm(-(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 + (3*(2*MB**2 + MZ**2)*Ncol*(MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**4))/(1296.*cmath.pi**2)) )'},
                               texname = '\delta e^{MB}')
 
 
 dMB_SWCoup_UV_EW = CTParameter(name = 'dMB_SWCoup_UV_EW',
                                type = 'complex',
-                               value = {-1:'( 0 if MB == 0 else re(-(ee**2*MB**2*(MW - cw*MZ)*(MW + cw*MZ)*Ncol)/(64.*MW**2*MZ**2*cmath.pi**2*sw**3)) )',
-                                         0:'( 0 if MB == 0 else re((ee**2*MB**2*(MW**2 - cw**2*MZ**2)*Ncol*reglog(4*cmath.pi))/(64.*MW**2*MZ**2*cmath.pi**2*sw**3) + (cw**2*(-(ee**2*Ncol*(-2*MB**2*MW**2*(MB**2 - 2*MT**2 + MW**2*(2 + reglog(64.) + 3*reglog(cmath.pi))) + 2*MB**2*MW**2*(MB**2 - MT**2 - 2*MW**2)*reglog(MU_R**2/MB**2) + 2*MW**2*(-(MB**2*MT**2) + MT**4 + MT**2*MW**2 - 2*MW**4)*reglog(MU_R**2/MT**2) + 2*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglog((MW**2 + vep*complex(0,-1))/MU_R**2) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglog((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)) - (MB**4 + MT**4 + MT**2*MW**2 - 2*MW**4 + MB**2*(-2*MT**2 + MW**2))*(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))) + (MB**4 + MT**4 + MT**2*MW**2 - 2*MW**4 + MB**2*(-2*MT**2 + MW**2))*(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglog((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1)))))))/(192.*MW**6*cmath.pi**2*sw**2) + (ee**2*(2*MB**2*Ncol*(-18 - 48*sw**2 + 32*sw**4 - reglog(18014398509481984.) - 27*reglog(cmath.pi)) - 4*MB**2*Ncol*(9 - 12*sw**2 + 8*sw**4)*reglog(MU_R**2/MB**2) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2) + 4*MZ**2*(27*(1 - 2*sw**2 + 4*sw**4) + 2*Ncol*(9 - 18*sw**2 + 20*sw**4))*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 2*MZ**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**2))/(1728.*cw**2*MZ**2*cmath.pi**2*sw**2)))/(2.*sw)) )'},
+                               value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0 and (WW != 0 or WZ != 0),-(ee**2*MB**2*(MW - cw*MZ)*(MW + cw*MZ)*Ncol)/(64.*MW**2*MZ**2*cmath.pi**2*sw**3)) )',
+                                         0:'( 0 if MB == 0 else recms(CMSParam==1.0 and (WW != 0 or WZ != 0),(ee**2*MB**2*(MW**2 - cw**2*MZ**2)*Ncol*reglog(4*cmath.pi))/(64.*MW**2*MZ**2*cmath.pi**2*sw**3) + (cw**2*(-(ee**2*Ncol*(-2*MB**2*MW**2*(MB**2 - 2*MT**2 + MW**2*(2 + reglog(64.) + 3*reglog(cmath.pi))) + 2*MB**2*MW**2*(MB**2 - MT**2 - 2*MW**2)*(-reglog(MB**2/MU_R**2)) + 2*MW**2*(-(MB**2*MT**2) + MT**4 + MT**2*MW**2 - 2*MW**4)*reglog(MU_R**2/MT**2) + 2*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*reglogm((MT**2 - MW**2 + vep*complex(0,-1))/MT**2) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglog((MW**2 + vep*complex(0,-1))/MU_R**2) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglogm((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)) - (MB**4 + MT**4 + MT**2*MW**2 - 2*MW**4 + MB**2*(-2*MT**2 + MW**2))*(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))) + (MB**4 + MT**4 + MT**2*MW**2 - 2*MW**4 + MB**2*(-2*MT**2 + MW**2))*(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglogm((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1)))))))/(192.*MW**6*cmath.pi**2*sw**2) + (ee**2*(2*MB**2*Ncol*(-18 - 48*sw**2 + 32*sw**4 - reglog(18014398509481984.) - 27*reglog(cmath.pi)) - 4*MB**2*Ncol*(9 - 12*sw**2 + 8*sw**4)*(-reglog(MB**2/MU_R**2)) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2) + 4*MZ**2*(27*(1 - 2*sw**2 + 4*sw**4) + 2*Ncol*(9 - 18*sw**2 + 20*sw**4))*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 2*MZ**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglogm((-MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**2))/(1728.*cw**2*MZ**2*cmath.pi**2*sw**2)))/(2.*sw)) )'},
                                texname = '\delta SW^{MB}')
 
 
 dMB_CWCoup_UV_EW = CTParameter(name = 'dMB_CWCoup_UV_EW',
                                type = 'complex',
-                               value = {-1:'( 0 if MB == 0 else re((ee**2*MB**2*(MW**2 - cw**2*MZ**2)*Ncol)/(64.*cw*MW**2*MZ**2*cmath.pi**2*sw**2)) )',
-                                         0:'( 0 if MB == 0 else re(-(ee**2*MB**2*(MW**2 - cw**2*MZ**2)*Ncol*reglog(4*cmath.pi))/(64.*cw*MW**2*MZ**2*cmath.pi**2*sw**2) + (cw*((ee**2*Ncol*(-2*MB**2*MW**2*(MB**2 - 2*MT**2 + MW**2*(2 + reglog(64.) + 3*reglog(cmath.pi))) + 2*MB**2*MW**2*(MB**2 - MT**2 - 2*MW**2)*reglog(MU_R**2/MB**2) + 2*MW**2*(-(MB**2*MT**2) + MT**4 + MT**2*MW**2 - 2*MW**4)*reglog(MU_R**2/MT**2) + 2*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglog((MW**2 + vep*complex(0,-1))/MU_R**2) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglog((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)) - (MB**4 + MT**4 + MT**2*MW**2 - 2*MW**4 + MB**2*(-2*MT**2 + MW**2))*(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglog((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))) + (MB**4 + MT**4 + MT**2*MW**2 - 2*MW**4 + MB**2*(-2*MT**2 + MW**2))*(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglog((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1)))))))/(192.*MW**6*cmath.pi**2*sw**2) - (ee**2*(2*MB**2*Ncol*(-18 - 48*sw**2 + 32*sw**4 - reglog(18014398509481984.) - 27*reglog(cmath.pi)) - 4*MB**2*Ncol*(9 - 12*sw**2 + 8*sw**4)*reglog(MU_R**2/MB**2) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2) + 4*MZ**2*(27*(1 - 2*sw**2 + 4*sw**4) + 2*Ncol*(9 - 18*sw**2 + 20*sw**4))*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 2*MZ**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**2))/(1728.*cw**2*MZ**2*cmath.pi**2*sw**2)))/2.) )'},
+                               value = {-1:'( 0 if MB == 0 else recms(CMSParam==1.0 and (WW != 0 or WZ != 0),(ee**2*MB**2*(MW**2 - cw**2*MZ**2)*Ncol)/(64.*cw*MW**2*MZ**2*cmath.pi**2*sw**2)) )',
+                                         0:'( 0 if MB == 0 else recms(CMSParam==1.0 and (WW != 0 or WZ != 0),-(ee**2*MB**2*(MW**2 - cw**2*MZ**2)*Ncol*reglog(4*cmath.pi))/(64.*cw*MW**2*MZ**2*cmath.pi**2*sw**2) + (cw*((ee**2*Ncol*(-2*MB**2*MW**2*(MB**2 - 2*MT**2 + MW**2*(2 + reglog(64.) + 3*reglog(cmath.pi))) + 2*MB**2*MW**2*(MB**2 - MT**2 - 2*MW**2)*(-reglog(MB**2/MU_R**2)) + 2*MW**2*(-(MB**2*MT**2) + MT**4 + MT**2*MW**2 - 2*MW**4)*reglog(MU_R**2/MT**2) + 2*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*reglogm((MT**2 - MW**2 + vep*complex(0,-1))/MT**2) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglog((MW**2 + vep*complex(0,-1))/MU_R**2) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglogm((MB**2 - MT**2 - MW**2 - cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)) - 2*MW**2*(-MB**4 - MT**4 - MT**2*MW**2 + 2*MW**4 + MB**2*(2*MT**2 - MW**2))*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(2.*MW**2)) - (MB**4 + MT**4 + MT**2*MW**2 - 2*MW**4 + MB**2*(-2*MT**2 + MW**2))*(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglogm((MB**2 - MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(MB**2 - MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))) + (MB**4 + MT**4 + MT**2*MW**2 - 2*MW**4 + MB**2*(-2*MT**2 + MW**2))*(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))*reglogm((-MB**2 + MT**2 + MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1))))/(-MB**2 + MT**2 - MW**2 + cmath.sqrt((MB**2 - MT**2 + MW**2)**2 - 4*MW**2*(MB**2 + vep*complex(0,-1)))))))/(192.*MW**6*cmath.pi**2*sw**2) - (ee**2*(2*MB**2*Ncol*(-18 - 48*sw**2 + 32*sw**4 - reglog(18014398509481984.) - 27*reglog(cmath.pi)) - 4*MB**2*Ncol*(9 - 12*sw**2 + 8*sw**4)*(-reglog(MB**2/MU_R**2)) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2) + 4*MZ**2*(27*(1 - 2*sw**2 + 4*sw**4) + 2*Ncol*(9 - 18*sw**2 + 20*sw**4))*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 2*MZ**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglogm((-MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - 2*Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (Ncol*(MZ**2*(9 - 12*sw**2 + 8*sw**4) + MB**2*(-9 - 24*sw**2 + 16*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))*reglogm((MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MB**2 + MZ**2 + vep*complex(0,4))))))/MZ**2))/(1728.*cw**2*MZ**2*cmath.pi**2*sw**2)))/2.) )'},
                                texname = '\delta CW^{MB}')
 
 
@@ -318,33 +318,40 @@
 
 tMass_UV_EW = CTParameter(name = 'tMass_UV_EW',
                           type = 'complex',
-                          value = {-1:'re((ee**2*MT*(MW**2*(3 + 24*sw**2 - 32*sw**4) + cw**2*(9*MT**2 + 2*MW**2*(3 - 16*sw**2))))/(384.*cw**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_tMass_UV_EW.value[-1],
-                          0:'re(-(ee**2*(9*cw**2*MH**2*MT**2 - 72*cw**2*MT**4 - 18*MT**2*MW**2 - 9*cw**2*MT**2*MW**2 + 18*cw**2*MW**4 + 9*cw**2*MT**2*MZ**2 + 9*MW**2*MZ**2 - 96*MT**2*MW**2*sw**2 + 128*cw**2*MT**2*MW**2*sw**2 - 24*MW**2*MZ**2*sw**2 + 128*MT**2*MW**2*sw**4 + 32*MW**2*MZ**2*sw**4 - 9*cw**2*MT**4*reglog(16) + 9*cw**2*MT**4*reglog(1/(4.*cmath.pi)) + 9*MT**2*MW**2*reglog(1/(4.*cmath.pi)) - 24*MT**2*MW**2*sw**2*reglog(1/(4.*cmath.pi)) + 16*MT**2*MW**2*sw**4*reglog(1/(4.*cmath.pi)) - 18*cw**2*MT**4*reglog(cmath.pi) + 96*MT**2*MW**2*sw**2*reglog(cmath.pi) - 112*cw**2*MT**2*MW**2*sw**2*reglog(cmath.pi) - 128*MT**2*MW**2*sw**4*reglog(cmath.pi) - 192*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 224*cw**2*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 256*MT**2*MW**2*sw**4*reglog(2*cmath.pi) + 27*cw**2*MT**4*reglog(4*cmath.pi) + 9*MT**2*MW**2*reglog(4*cmath.pi) + 72*MT**2*MW**2*sw**2*reglog(4*cmath.pi) - 112*cw**2*MT**2*MW**2*sw**2*reglog(4*cmath.pi) - 112*MT**2*MW**2*sw**4*reglog(4*cmath.pi)))/(1152.*cw**2*MT*MW**2*cmath.pi**2*sw**2) + (ee**2*MH**2*MT*reglog(MU_R**2/MH**2))/(128.*MW**2*cmath.pi**2*sw**2) - (ee**2*MT*(18*cw**2*MT**2 + 9*MW**2 - 24*MW**2*sw**2 + 96*cw**2*MW**2*sw**2 + 32*MW**2*sw**4)*reglog(MU_R**2/MT**2))/(1152.*cw**2*MW**2*cmath.pi**2*sw**2) + (ee**2*MT*(MT**2 + 2*MW**2)*reglog(MU_R**2/MW**2))/(128.*MW**2*cmath.pi**2*sw**2) + (ee**2*MZ**2*(9*cw**2*MT**2 + 9*MW**2 - 24*MW**2*sw**2 + 32*MW**2*sw**4)*reglog(MU_R**2/MZ**2))/(1152.*cw**2*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*(-9*cw**2*MH**2*MT**2 + 36*cw**2*MT**4 + 18*MT**2*MW**2 - 9*cw**2*MT**2*MZ**2 - 9*MW**2*MZ**2 + 48*MT**2*MW**2*sw**2 + 24*MW**2*MZ**2*sw**2 - 64*MT**2*MW**2*sw**4 - 32*MW**2*MZ**2*sw**4)*reglog((MT**2 + vep*complex(0,-1))/MU_R**2))/(1152.*cw**2*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*reglog((-MT**2 + MW**2 + vep*complex(0,-1))/MW**2))/(128.*MT**3*MW**2*cmath.pi**2*sw**2) + (ee**2*(-18*MT**2*MW**2 + 9*cw**2*MT**2*MZ**2 + 9*MW**2*MZ**2 - 48*MT**2*MW**2*sw**2 - 24*MW**2*MZ**2*sw**2 + 64*MT**2*MW**2*sw**4 + 32*MW**2*MZ**2*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2.*MT**2)))/(1152.*cw**2*MT*MW**2*cmath.pi**2*sw**2) + (ee**2*(-18*MT**2*MW**2 + 9*cw**2*MT**2*MZ**2 + 9*MW**2*MZ**2 - 48*MT**2*MW**2*sw**2 - 24*MW**2*MZ**2*sw**2 + 64*MT**2*MW**2*sw**4 + 32*MW**2*MZ**2*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2.*MT**2)))/(1152.*cw**2*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*(-18*MT**2*MW**2 + 9*cw**2*MT**2*MZ**2 + 9*MW**2*MZ**2 - 48*MT**2*MW**2*sw**2 - 24*MW**2*MZ**2*sw**2 + 64*MT**2*MW**2*sw**4 + 32*MW**2*MZ**2*sw**4)*(2*MT**2 - MZ**2 + cmath.sqrt(-4*MT**2*MZ**2 + MZ**4 + MT**2*vep*complex(0,4)))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2*MT**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))))/(2304.*cw**2*MT**3*MW**2*cmath.pi**2*sw**2) - (ee**2*(-18*MT**2*MW**2 + 9*cw**2*MT**2*MZ**2 + 9*MW**2*MZ**2 - 48*MT**2*MW**2*sw**2 - 24*MW**2*MZ**2*sw**2 + 64*MT**2*MW**2*sw**4 + 32*MW**2*MZ**2*sw**4)*(2*MT**2 - MZ**2 - cmath.sqrt(-4*MT**2*MZ**2 + MZ**4 + MT**2*vep*complex(0,4)))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(-2*MT**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))))/(2304.*cw**2*MT**3*MW**2*cmath.pi**2*sw**2) - (ee**2*MT*(-MH + 2*MT)*(MH + 2*MT)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MT**2*(MH**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MW**2*cmath.pi**2*sw**2) - (ee**2*MT*(-MH + 2*MT)*(MH + 2*MT)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MT**2*(MH**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MW**2*cmath.pi**2*sw**2) + (ee**2*(-MH + 2*MT)*(MH + 2*MT)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))*reglog((MH**2 - 2*MT**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))))/(256.*MT*MW**2*cmath.pi**2*sw**2) + (ee**2*(-MH + 2*MT)*(MH + 2*MT)*(MH**2 - cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MT**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))))/(256.*MT*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_tMass_UV_EW.value[0]},
+                          value = {-1:'recms(CMSParam==1.0 and WT != 0,(ee**2*MT*(MW**2*(3 + 24*sw**2 - 32*sw**4) + cw**2*(9*MT**2 + 2*MW**2*(3 - 16*sw**2))))/(384.*cw**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_tMass_UV_EW.value[-1],
+                          0:'recms(CMSParam==1.0  and WT != 0,-(ee**2*(9*cw**2*MH**2*MT**2 - 72*cw**2*MT**4 - 18*MT**2*MW**2 - 9*cw**2*MT**2*MW**2 + 18*cw**2*MW**4 + 9*cw**2*MT**2*MZ**2 + 9*MW**2*MZ**2 - 96*MT**2*MW**2*sw**2 + 128*cw**2*MT**2*MW**2*sw**2 - 24*MW**2*MZ**2*sw**2 + 128*MT**2*MW**2*sw**4 + 32*MW**2*MZ**2*sw**4 - 9*cw**2*MT**4*reglog(16) + 9*cw**2*MT**4*reglog(1/(4.*cmath.pi)) + 9*MT**2*MW**2*reglog(1/(4.*cmath.pi)) - 24*MT**2*MW**2*sw**2*reglog(1/(4.*cmath.pi)) + 16*MT**2*MW**2*sw**4*reglog(1/(4.*cmath.pi)) - 18*cw**2*MT**4*reglog(cmath.pi) + 96*MT**2*MW**2*sw**2*reglog(cmath.pi) - 112*cw**2*MT**2*MW**2*sw**2*reglog(cmath.pi) - 128*MT**2*MW**2*sw**4*reglog(cmath.pi) - 192*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 224*cw**2*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 256*MT**2*MW**2*sw**4*reglog(2*cmath.pi) + 27*cw**2*MT**4*reglog(4*cmath.pi) + 9*MT**2*MW**2*reglog(4*cmath.pi) + 72*MT**2*MW**2*sw**2*reglog(4*cmath.pi) - 112*cw**2*MT**2*MW**2*sw**2*reglog(4*cmath.pi) - 112*MT**2*MW**2*sw**4*reglog(4*cmath.pi)))/(1152.*cw**2*MT*MW**2*cmath.pi**2*sw**2) + (ee**2*MH**2*MT*reglog(MU_R**2/MH**2))/(128.*MW**2*cmath.pi**2*sw**2) - (ee**2*MT*(18*cw**2*MT**2 + 9*MW**2 - 24*MW**2*sw**2 + 96*cw**2*MW**2*sw**2 + 32*MW**2*sw**4)*reglog(MU_R**2/MT**2))/(1152.*cw**2*MW**2*cmath.pi**2*sw**2) + (ee**2*MT*(MT**2 + 2*MW**2)*reglog(MU_R**2/MW**2))/(128.*MW**2*cmath.pi**2*sw**2) + (ee**2*MZ**2*(9*cw**2*MT**2 + 9*MW**2 - 24*MW**2*sw**2 + 32*MW**2*sw**4)*reglog(MU_R**2/MZ**2))/(1152.*cw**2*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*(-9*cw**2*MH**2*MT**2 + 36*cw**2*MT**4 + 18*MT**2*MW**2 - 9*cw**2*MT**2*MZ**2 - 9*MW**2*MZ**2 + 48*MT**2*MW**2*sw**2 + 24*MW**2*MZ**2*sw**2 - 64*MT**2*MW**2*sw**4 - 32*MW**2*MZ**2*sw**4)*reglog((MT**2 + vep*complex(0,-1))/MU_R**2))/(1152.*cw**2*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*reglogm((-MT**2 + MW**2 + vep*complex(0,-1))/MW**2))/(128.*MT**3*MW**2*cmath.pi**2*sw**2) + (ee**2*(-18*MT**2*MW**2 + 9*cw**2*MT**2*MZ**2 + 9*MW**2*MZ**2 - 48*MT**2*MW**2*sw**2 - 24*MW**2*MZ**2*sw**2 + 64*MT**2*MW**2*sw**4 + 32*MW**2*MZ**2*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2.*MT**2)))/(1152.*cw**2*MT*MW**2*cmath.pi**2*sw**2) + (ee**2*(-18*MT**2*MW**2 + 9*cw**2*MT**2*MZ**2 + 9*MW**2*MZ**2 - 48*MT**2*MW**2*sw**2 - 24*MW**2*MZ**2*sw**2 + 64*MT**2*MW**2*sw**4 + 32*MW**2*MZ**2*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2.*MT**2)))/(1152.*cw**2*MT*MW**2*cmath.pi**2*sw**2) - (ee**2*(-18*MT**2*MW**2 + 9*cw**2*MT**2*MZ**2 + 9*MW**2*MZ**2 - 48*MT**2*MW**2*sw**2 - 24*MW**2*MZ**2*sw**2 + 64*MT**2*MW**2*sw**4 + 32*MW**2*MZ**2*sw**4)*(2*MT**2 - MZ**2 + cmath.sqrt(-4*MT**2*MZ**2 + MZ**4 + MT**2*vep*complex(0,4)))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2*MT**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))))/(2304.*cw**2*MT**3*MW**2*cmath.pi**2*sw**2) - (ee**2*(-18*MT**2*MW**2 + 9*cw**2*MT**2*MZ**2 + 9*MW**2*MZ**2 - 48*MT**2*MW**2*sw**2 - 24*MW**2*MZ**2*sw**2 + 64*MT**2*MW**2*sw**4 + 32*MW**2*MZ**2*sw**4)*(2*MT**2 - MZ**2 - cmath.sqrt(-4*MT**2*MZ**2 + MZ**4 + MT**2*vep*complex(0,4)))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(-2*MT**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))))/(2304.*cw**2*MT**3*MW**2*cmath.pi**2*sw**2) - (ee**2*MT*(-MH + 2*MT)*(MH + 2*MT)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MT**2*(MH**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MW**2*cmath.pi**2*sw**2) - (ee**2*MT*(-MH + 2*MT)*(MH + 2*MT)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MT**2*(MH**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MW**2*cmath.pi**2*sw**2) + (ee**2*(-MH + 2*MT)*(MH + 2*MT)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))*reglog((MH**2 - 2*MT**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))))/(256.*MT*MW**2*cmath.pi**2*sw**2) + (ee**2*(-MH + 2*MT)*(MH + 2*MT)*(MH**2 - cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MT**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))))/(256.*MT*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_tMass_UV_EW.value[0]},
                           texname = '\delta m_t^{EW}')
 
 HMass2_UV_EW = CTParameter(name = 'HMass2_UV_EW',
                            type = 'complex',
-                           value = {-1:'re((ee**2*(16*MW**4 + 2*cw**2*MW**2*(-2*MH**2 + MZ**2) + cw**4*(15*MH**4 + 36*MW**4 - 24*MT**4*Ncol + MH**2*(-6*MW**2 + MZ**2 + 4*MT**2*Ncol))))/(128.*cw**4*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_HMass2_UV_EW.value[-1],
-                                    0:'re(-(ee**2*(16*MW**4 + 2*cw**2*MW**2*(-2*MH**2 + MZ**2) + cw**4*(15*MH**4 + 36*MW**4 - 24*MT**4*Ncol + MH**2*(-6*MW**2 + MZ**2 + 4*MT**2*Ncol)))*reglog(4*cmath.pi))/(128.*cw**4*MW**2*cmath.pi**2*sw**2) + (ee**2*((-2*(8*MW**4*(-3 - reglog(16) - 2*reglog(cmath.pi)) + 2*cw**2*MW**2*(MZ**2*(3 + reglog(1/(4.*cmath.pi))) + MH**2*(4 + reglog(16) + 2*reglog(cmath.pi))) + cw**4*(4*(9*MW**4*(-1 + reglog(1/(4.*cmath.pi))) + 2*MT**4*Ncol*(5 + reglog(64) + 3*reglog(cmath.pi))) + 3*MH**4*(-9 + 5*reglog(cmath.pi) - 10*reglog(2*cmath.pi)) - MH**2*(MW**2*(-14 - reglog(4096) - 6*reglog(cmath.pi)) + MT**2*Ncol*(8 + reglog(256) + 4*reglog(cmath.pi)) + MZ**2*(1 + reglog(4*cmath.pi))))))/(cw**4*MW**2) + (6*MH**4*reglog(MU_R**2/MH**2))/MW**2 - (16*MT**4*Ncol*reglog(MU_R**2/MT**2))/MW**2 + 4*(MH**2 + 6*MW**2)*reglog(MU_R**2/MW**2) + (2*(cw**2*MH**2 + 6*MW**2)*MZ**2*reglog(MU_R**2/MZ**2))/(cw**2*MW**2) - (8*(4*MW**4 - cw**2*MW**2*(MH**2 + MZ**2) + cw**4*(3*MH**4 + 6*MW**4 - 4*MT**4*Ncol + MH**2*(-2*MW**2 + MT**2*Ncol)))*reglog((MH**2 + vep*complex(0,-1))/MU_R**2))/(cw**4*MW**2) + (8*MT**2*(-MH + 2*MT)*(MH + 2*MT)*Ncol*reglog((-MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(2.*MH**2)))/MW**2 + (8*MT**2*(-MH + 2*MT)*(MH + 2*MT)*Ncol*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(2.*MH**2)))/MW**2 + (4*(MH - 2*MT)*MT**2*(MH + 2*MT)*Ncol*(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))))/(MH**2*MW**2) + (4*(MH - 2*MT)*MT**2*(MH + 2*MT)*Ncol*(MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))))/(MH**2*MW**2) - (4*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog((-MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(2.*MH**2)))/MW**2 - (4*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(2.*MH**2)))/MW**2 + (2*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))))/(MH**2*MW**2) + (2*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))))/(MH**2*MW**2) - (2*(cw**4*MH**4 + 16*MW**4 - 4*cw**2*MW**2*(MH**2 + MZ**2))*reglog((-MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(2.*MH**2)))/(cw**4*MW**2) - (2*(cw**4*MH**4 + 16*MW**4 - 4*cw**2*MW**2*(MH**2 + MZ**2))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(2.*MH**2)))/(cw**4*MW**2) + ((cw**4*MH**4 + 16*MW**4 - 4*cw**2*MW**2*(MH**2 + MZ**2))*(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))))/(cw**4*MH**2*MW**2) + ((cw**4*MH**4 + 16*MW**4 - 4*cw**2*MW**2*(MH**2 + MZ**2))*(MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))))/(cw**4*MH**2*MW**2) + (9*MH**2*(MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))*reglog((-MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))))/MW**2 + (9*MH**2*(MH**2 - cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))*reglog((MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))))/MW**2 - (18*MH**4*reglog(-0.5 - cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4))/(2.*MH**2)))/MW**2 - (18*MH**4*reglog(-0.5 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4))/(2.*MH**2)))/MW**2))/(256.*cmath.pi**2*sw**2))'+'+'+dMB_HMass2_UV_EW.value[0]},
+                           value = {-1:'recms(CMSParam==1.0 and WH != 0,(ee**2*(16*MW**4 + 2*cw**2*MW**2*(-2*MH**2 + MZ**2) + cw**4*(15*MH**4 + 36*MW**4 - 24*MT**4*Ncol + MH**2*(-6*MW**2 + MZ**2 + 4*MT**2*Ncol))))/(128.*cw**4*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_HMass2_UV_EW.value[-1],
+                                    0:'recms(CMSParam==1.0 and WH != 0,-(ee**2*(16*MW**4 + 2*cw**2*MW**2*(-2*MH**2 + MZ**2) + cw**4*(15*MH**4 + 36*MW**4 - 24*MT**4*Ncol + MH**2*(-6*MW**2 + MZ**2 + 4*MT**2*Ncol)))*reglog(4*cmath.pi))/(128.*cw**4*MW**2*cmath.pi**2*sw**2) + (ee**2*((-2*(8*MW**4*(-3 - reglog(16) - 2*reglog(cmath.pi)) + 2*cw**2*MW**2*(MZ**2*(3 + reglog(1/(4.*cmath.pi))) + MH**2*(4 + reglog(16) + 2*reglog(cmath.pi))) + cw**4*(4*(9*MW**4*(-1 + reglog(1/(4.*cmath.pi))) + 2*MT**4*Ncol*(5 + reglog(64) + 3*reglog(cmath.pi))) + 3*MH**4*(-9 + 5*reglog(cmath.pi) - 10*reglog(2*cmath.pi)) - MH**2*(MW**2*(-14 - reglog(4096) - 6*reglog(cmath.pi)) + MT**2*Ncol*(8 + reglog(256) + 4*reglog(cmath.pi)) + MZ**2*(1 + reglog(4*cmath.pi))))))/(cw**4*MW**2) + (6*MH**4*reglog(MU_R**2/MH**2))/MW**2 - (16*MT**4*Ncol*reglog(MU_R**2/MT**2))/MW**2 + 4*(MH**2 + 6*MW**2)*reglog(MU_R**2/MW**2) + (2*(cw**2*MH**2 + 6*MW**2)*MZ**2*reglog(MU_R**2/MZ**2))/(cw**2*MW**2) - (8*(4*MW**4 - cw**2*MW**2*(MH**2 + MZ**2) + cw**4*(3*MH**4 + 6*MW**4 - 4*MT**4*Ncol + MH**2*(-2*MW**2 + MT**2*Ncol)))*reglog((MH**2 + vep*complex(0,-1))/MU_R**2))/(cw**4*MW**2) + (8*MT**2*(-MH + 2*MT)*(MH + 2*MT)*Ncol*reglog((-MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(2.*MH**2)))/MW**2 + (8*MT**2*(-MH + 2*MT)*(MH + 2*MT)*Ncol*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(2.*MH**2)))/MW**2 + (4*(MH - 2*MT)*MT**2*(MH + 2*MT)*Ncol*(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))))/(MH**2*MW**2) + (4*(MH - 2*MT)*MT**2*(MH + 2*MT)*Ncol*(MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))))/(MH**2*MW**2) - (4*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog((-MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(2.*MH**2)))/MW**2 - (4*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(2.*MH**2)))/MW**2 + (2*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))))/(MH**2*MW**2) + (2*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))))/(MH**2*MW**2) - (2*(cw**4*MH**4 + 16*MW**4 - 4*cw**2*MW**2*(MH**2 + MZ**2))*reglog((-MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(2.*MH**2)))/(cw**4*MW**2) - (2*(cw**4*MH**4 + 16*MW**4 - 4*cw**2*MW**2*(MH**2 + MZ**2))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(2.*MH**2)))/(cw**4*MW**2) + ((cw**4*MH**4 + 16*MW**4 - 4*cw**2*MW**2*(MH**2 + MZ**2))*(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))))/(cw**4*MH**2*MW**2) + ((cw**4*MH**4 + 16*MW**4 - 4*cw**2*MW**2*(MH**2 + MZ**2))*(MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))))/(cw**4*MH**2*MW**2) + (9*MH**2*(MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))*reglog((-MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))))/MW**2 + (9*MH**2*(MH**2 - cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))*reglog((MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))))/MW**2 - (18*MH**4*reglog(-0.5 - cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4))/(2.*MH**2)))/MW**2 - (18*MH**4*reglog(-0.5 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4))/(2.*MH**2)))/MW**2))/(256.*cmath.pi**2*sw**2))'+'+'+dMB_HMass2_UV_EW.value[0]},
                            texname = '\delta m2_H^{EW}')
 
+# adding term of B0[MW^2-iGW*MW,0,MW^2-iGW*MW]-B0[s,0,MW^2-iGW*MW]
+
+#WMass2_UV_EW_add = CTParameter(name = 'WMass2_UV_EW_add',
+#                               type = 'complex',
+#                               value = {0:'-lhv*ee**2*MW**2*complex(0,1)*im(MW**2)*reglog(complex(0,1)*im(MW**2)/MW**2)/(4.*cmath.pi**2*re(MW**2))'},
+#                               texname = '\delta m2_W^{EW,add}')
+
 WMass2_UV_EW = CTParameter(name = 'WMass2_UV_EW',
                            type = 'complex',
-                           value = {-1:'re(-(ee**2*(cw**4*(44*MW**2 + 6*MZ**2) - 6*MW**2*sw**4 + cw**2*(3*MT**2*Ncol + MW**2*(-31 - 6*Ncol + 38*sw**2))))/(96.*cw**2*cmath.pi**2*sw**2))'+'+'+dMB_WMass2_UV_EW.value[-1],
-                           0:'re((ee**2*(cw**4*(44*MW**2 + 6*MZ**2) - 6*MW**2*sw**4 + cw**2*(3*MT**2*Ncol + MW**2*(-31 - 6*Ncol + 38*sw**2)))*reglog(4*cmath.pi))/(96.*cw**2*cmath.pi**2*sw**2) + (ee**2*((2*(cw**2*(3*MH**4 - 18*MH**2*MW**2 + 3*(MZ**4 - 2*MT**4*Ncol) - 6*MW**2*(3*MZ**2 + MT**2*Ncol*(2 + reglog(64) + 3*reglog(cmath.pi))) - 2*MW**4*(-83 + 178*sw**2 + 93*reglog(cmath.pi) - 114*sw**2*reglog(cmath.pi) - 6*Ncol*(5 + reglog(64) + 3*reglog(cmath.pi)) - 186*reglog(2*cmath.pi) + 228*sw**2*reglog(2*cmath.pi))) + 4*cw**4*(6*MZ**4 + MW**4*(-107 + 66*reglog(cmath.pi) - 132*reglog(2*cmath.pi)) + 9*MW**2*MZ**2*(-6 - reglog(4*cmath.pi))) + 36*MW**4*sw**4*(2 + reglog(4*cmath.pi))))/(cw**2*MW**2) - (6*MH**2*(MH**2 - 3*MW**2)*reglog(MU_R**2/MH**2))/MW**2 - 12*(3*MT**2 - 2*MW**2)*Ncol*reglog(MU_R**2/MT**2) + 6*(MH**2 + (1 + 8*cw**2)*MZ**2 + MW**2*(38 - 28*cw**2 - 76*sw**2))*reglog(MU_R**2/MW**2) - (6*(1 + 8*cw**2)*MZ**2*(-3*MW**2 + MZ**2)*reglog(MU_R**2/MZ**2))/MW**2 - (12*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*Ncol*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2))/MW**4 + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) - cw**2*(MH**4 - 4*MH**2*MW**2 + 12*MW**4 - 4*MW**2*MZ**2 + MZ**4) - 12*MW**4*sw**4)*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/(cw**2*MW**2) + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**2) + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**2) - (3*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**4) + (3*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**4) - (6*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/MW**2 - (6*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/MW**2 + 24*MW**2*(3 + 2*Ncol)*reglog(-(MU_R**2/(MW**2 + vep*complex(0,1)))) + (3*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((MH**2 - 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/MW**4 - (3*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/MW**4))/(1152.*cmath.pi**2*sw**2))'+'+'+dMB_WMass2_UV_EW.value[0]},
+                           value = {-1:'recms(CMSParam==1.0 and WW != 0,-(ee**2*(cw**4*(44*MW**2 + 6*MZ**2) - 6*MW**2*sw**4 + cw**2*(3*MT**2*Ncol + MW**2*(-31 - 6*Ncol + 38*sw**2))))/(96.*cw**2*cmath.pi**2*sw**2))'+'+'+dMB_WMass2_UV_EW.value[-1],
+                           0:'recms(CMSParam==1.0 and WW != 0,(ee**2*(cw**4*(44*MW**2 + 6*MZ**2) - 6*MW**2*sw**4 + cw**2*(3*MT**2*Ncol + MW**2*(-31 - 6*Ncol + 38*sw**2)))*reglog(4*cmath.pi))/(96.*cw**2*cmath.pi**2*sw**2) + (ee**2*((2*(cw**2*(3*MH**4 - 18*MH**2*MW**2 + 3*(MZ**4 - 2*MT**4*Ncol) - 6*MW**2*(3*MZ**2 + MT**2*Ncol*(2 + reglog(64) + 3*reglog(cmath.pi))) - 2*MW**4*(-83 + 178*sw**2 + 93*reglog(cmath.pi) - 114*sw**2*reglog(cmath.pi) - 6*Ncol*(5 + reglog(64) + 3*reglog(cmath.pi)) - 186*reglog(2*cmath.pi) + 228*sw**2*reglog(2*cmath.pi))) + 4*cw**4*(6*MZ**4 + MW**4*(-107 + 66*reglog(cmath.pi) - 132*reglog(2*cmath.pi)) + 9*MW**2*MZ**2*(-6 - reglog(4*cmath.pi))) + 36*MW**4*sw**4*(2 + reglog(4*cmath.pi))))/(cw**2*MW**2) - (6*MH**2*(MH**2 - 3*MW**2)*reglog(MU_R**2/MH**2))/MW**2 - 12*(3*MT**2 - 2*MW**2)*Ncol*reglog(MU_R**2/MT**2) + 6*(MH**2 + (1 + 8*cw**2)*MZ**2 + MW**2*(38 - 28*cw**2 - 76*sw**2))*reglog(MU_R**2/MW**2) - (6*(1 + 8*cw**2)*MZ**2*(-3*MW**2 + MZ**2)*reglog(MU_R**2/MZ**2))/MW**2 - (12*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*Ncol*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2))/MW**4 + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) - cw**2*(MH**4 - 4*MH**2*MW**2 + 12*MW**4 - 4*MW**2*MZ**2 + MZ**4) - 12*MW**4*sw**4)*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/(cw**2*MW**2) + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**2) + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**2) - (3*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**4) + (3*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**4) - (6*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/MW**2 - (6*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/MW**2 + 24*MW**2*(3 + 2*Ncol)*reglogp(-(MU_R**2/(MW**2 + vep*complex(0,1)))) + (3*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((MH**2 - 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/MW**4 - (3*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/MW**4))/(1152.*cmath.pi**2*sw**2))'+'+'+dMB_WMass2_UV_EW.value[0]},
                            texname = '\delta m2_W^{EW}')
 
 ZMass2_UV_EW = CTParameter(name = 'ZMass2_UV_EW',
                           type = 'complex',
-                          value = {-1:'re(-(ee**2*(36*MW**2*(-1 + 2*cw**6 - 2*cw**2*sw**4) + cw**2*(18*MT**2*Ncol + MZ**2*(-39 + 117*cw**4 + 72*sw**2 + 6*cw**2*sw**2 - 147*sw**4 - 4*Ncol*(9 - 18*sw**2 + 20*sw**4)))))/(576.*cw**4*cmath.pi**2*sw**2))'+'+'+dMB_ZMass2_UV_EW.value[-1],
-                          0:'re((ee**2*(36*MW**2*(-1 + 2*cw**6 - 2*cw**2*sw**4) + cw**2*(18*MT**2*Ncol + MZ**2*(-39 + 117*cw**4 + 72*sw**2 + 6*cw**2*sw**2 - 147*sw**4 - 4*Ncol*(9 - 18*sw**2 + 20*sw**4))))*reglog(4*cmath.pi))/(576.*cw**4*cmath.pi**2*sw**2) + (ee**2*((2*(-108*MW**2*MZ**2*(-2 + reglog(1/(4.*cmath.pi))) + 6*cw**4*MZ**2*sw**2*(24*MW**2 + MZ**2*(-8 - reglog(64) - 3*reglog(cmath.pi))) + 9*cw**6*MZ**2*(24*MW**2*(-5 + reglog(1/(4.*cmath.pi))) + MZ**2*(-80 + 39*reglog(cmath.pi) - 78*reglog(2*cmath.pi))) + cw**2*(9*MH**4 - 54*MH**2*MZ**2 + MZ**2*(2*(-36*MW**2*sw**4*(-5 - reglog(64) - 3*reglog(cmath.pi)) + MT**2*Ncol*(-96*sw**2 + 128*sw**4 - 9*(2 + reglog(64) + 3*reglog(cmath.pi)))) + MZ**2*(4*Ncol*(9 - 18*sw**2 + 20*sw**4)*(5 + reglog(64) + 3*reglog(cmath.pi)) + 3*(59 - 39*reglog(cmath.pi) - 24*sw**2*(5 + reglog(64) + 3*reglog(cmath.pi)) + 78*reglog(2*cmath.pi) + sw**4*(248 - 147*reglog(cmath.pi) + 294*reglog(2*cmath.pi))))))))/MZ**2 - (18*cw**2*MH**2*(MH**2 - 3*MZ**2)*reglog(MU_R**2/MH**2))/MZ**2 - 8*cw**2*MT**2*Ncol*(9 - 24*sw**2 + 32*sw**4)*reglog(MU_R**2/MT**2) + 72*cw**2*MW**2*(9*cw**4 - 2*cw**2*sw**2 + sw**4)*reglog(MU_R**2/MW**2) + 18*cw**2*(MH**2 + MZ**2)*reglog(MU_R**2/MZ**2) + (2*(-108*MW**2*MZ**2 + 27*cw**6*(20*MW**2*MZ**2 + 13*MZ**4) + 18*cw**4*MZ**2*(-4*MW**2 + MZ**2)*sw**2 - cw**2*(9*MH**4 - 36*MH**2*MZ**2 + MZ**2*(180*MW**2*sw**4 + 2*MT**2*Ncol*(-9 - 48*sw**2 + 64*sw**4) + MZ**2*(9*sw**4 + 2*Ncol*(9 - 24*sw**2 + 32*sw**4)))))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/MZ**2 - (18*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/MZ**2 - (18*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/MZ**2 + 4*cw**2*MZ**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 4*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - 4*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (2*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (2*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + 18*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + 18*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - (9*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 - (9*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (9*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((MH**2 - 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/MZ**4 - (9*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/MZ**4))/(3456.*cw**4*cmath.pi**2*sw**2))'+'+'+dMB_ZMass2_UV_EW.value[0]},
+                          value = {-1:'recms(CMSParam==1.0 and WZ != 0,-(ee**2*(36*MW**2*(-1 + 2*cw**6 - 2*cw**2*sw**4) + cw**2*(18*MT**2*Ncol + MZ**2*(-39 + 117*cw**4 + 72*sw**2 + 6*cw**2*sw**2 - 147*sw**4 - 4*Ncol*(9 - 18*sw**2 + 20*sw**4)))))/(576.*cw**4*cmath.pi**2*sw**2))'+'+'+dMB_ZMass2_UV_EW.value[-1],
+                          0:'recms(CMSParam==1.0 and WZ != 0,(ee**2*(36*MW**2*(-1 + 2*cw**6 - 2*cw**2*sw**4) + cw**2*(18*MT**2*Ncol + MZ**2*(-39 + 117*cw**4 + 72*sw**2 + 6*cw**2*sw**2 - 147*sw**4 - 4*Ncol*(9 - 18*sw**2 + 20*sw**4))))*reglog(4*cmath.pi))/(576.*cw**4*cmath.pi**2*sw**2) + (ee**2*((2*(-108*MW**2*MZ**2*(-2 + reglog(1/(4.*cmath.pi))) + 6*cw**4*MZ**2*sw**2*(24*MW**2 + MZ**2*(-8 - reglog(64) - 3*reglog(cmath.pi))) + 9*cw**6*MZ**2*(24*MW**2*(-5 + reglog(1/(4.*cmath.pi))) + MZ**2*(-80 + 39*reglog(cmath.pi) - 78*reglog(2*cmath.pi))) + cw**2*(9*MH**4 - 54*MH**2*MZ**2 + MZ**2*(2*(-36*MW**2*sw**4*(-5 - reglog(64) - 3*reglog(cmath.pi)) + MT**2*Ncol*(-96*sw**2 + 128*sw**4 - 9*(2 + reglog(64) + 3*reglog(cmath.pi)))) + MZ**2*(4*Ncol*(9 - 18*sw**2 + 20*sw**4)*(5 + reglog(64) + 3*reglog(cmath.pi)) + 3*(59 - 39*reglog(cmath.pi) - 24*sw**2*(5 + reglog(64) + 3*reglog(cmath.pi)) + 78*reglog(2*cmath.pi) + sw**4*(248 - 147*reglog(cmath.pi) + 294*reglog(2*cmath.pi))))))))/MZ**2 - (18*cw**2*MH**2*(MH**2 - 3*MZ**2)*reglog(MU_R**2/MH**2))/MZ**2 - 8*cw**2*MT**2*Ncol*(9 - 24*sw**2 + 32*sw**4)*reglog(MU_R**2/MT**2) + 72*cw**2*MW**2*(9*cw**4 - 2*cw**2*sw**2 + sw**4)*reglog(MU_R**2/MW**2) + 18*cw**2*(MH**2 + MZ**2)*reglog(MU_R**2/MZ**2) + (2*(-108*MW**2*MZ**2 + 27*cw**6*(20*MW**2*MZ**2 + 13*MZ**4) + 18*cw**4*MZ**2*(-4*MW**2 + MZ**2)*sw**2 - cw**2*(9*MH**4 - 36*MH**2*MZ**2 + MZ**2*(180*MW**2*sw**4 + 2*MT**2*Ncol*(-9 - 48*sw**2 + 64*sw**4) + MZ**2*(9*sw**4 + 2*Ncol*(9 - 24*sw**2 + 32*sw**4)))))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/MZ**2 - (18*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/MZ**2 - (18*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/MZ**2 + 4*cw**2*MZ**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 4*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - 4*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (2*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (2*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + 18*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + 18*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - (9*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 - (9*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (9*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((MH**2 - 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/MZ**4 - (9*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/MZ**4))/(3456.*cw**4*cmath.pi**2*sw**2))'+'+'+dMB_ZMass2_UV_EW.value[0]},
                           texname = '\delta m2_Z^{EW}')
 
 
 tWcft_UV_EW_R = CTParameter(name = 'tWcft_UV_EW_R',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*(8*MW**2*sw**4 + 3*cw**2*(3*MT**2 + 8*MW**2*sw**2)))/(288.*cw**2*MW**2*cmath.pi**2*sw**2))',
-                            0:'re(-(ee**2*(27*cw**2*MH**2*MT**2 - 36*cw**2*MT**4 - 54*MT**2*MW**2 - 18*cw**2*MT**2*MW**2 + 72*cw**2*MW**4 + 27*cw**2*MT**2*MZ**2 + 36*MW**2*MZ**2 - 48*MT**2*MW**2*sw**2 + 128*cw**2*MT**2*MW**2*sw**2 - 96*MW**2*MZ**2*sw**2 + 128*MT**2*MW**2*sw**4 + 96*MW**2*MZ**2*sw**4 + 18*cw**2*MT**4*reglog(16) + 64*cw**2*MT**2*MW**2*sw**2*reglog(16) + 36*cw**2*MT**4*reglog(cmath.pi) + 128*cw**2*MT**2*MW**2*sw**2*reglog(cmath.pi) - 36*cw**2*MT**4*reglog(4*cmath.pi) - 128*cw**2*MT**2*MW**2*sw**2*reglog(4*cmath.pi)))/(1152.*cw**2*MT**2*MW**2*cmath.pi**2*sw**2) + (ee**2*(3*MH**2 - 4*MT**2)*reglog(MU_R**2/MH**2))/(128.*MW**2*cmath.pi**2*sw**2) - (ee**2*(24*cw**2*MT**4 + 18*MT**2*MW**2 - 9*cw**2*MT**2*MZ**2 - 6*MW**2*MZ**2 - 16*MT**2*MW**2*sw**2 + 64*cw**2*MT**2*MW**2*sw**2 + 16*MW**2*MZ**2*sw**2 - 16*cw**2*MW**2*MZ**2*sw**2 - 16*MW**2*MZ**2*sw**4)*reglog(MU_R**2/MT**2))/(192.*cw**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) - (ee**2*MT**2*reglog(MU_R**2/MW**2))/(64.*MW**2*cmath.pi**2*sw**2) + (ee**2*(-72*MT**4*MW**2 + 72*cw**2*MT**4*MZ**2 + 144*MT**2*MW**2*MZ**2 - 27*cw**2*MT**2*MZ**4 - 36*MW**2*MZ**4 - 192*MT**4*MW**2*sw**2 - 192*MT**2*MW**2*MZ**2*sw**2 + 96*MW**2*MZ**4*sw**2 + 256*MT**4*MW**2*sw**4 + 128*MT**2*MW**2*MZ**2*sw**4 - 96*MW**2*MZ**4*sw**4)*reglog(MU_R**2/MZ**2))/(1152.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) - (ee**2*(-36*cw**2*MH**2*MT**4 + 72*cw**2*MT**6 + 60*MT**4*MW**2 + 9*cw**2*MH**2*MT**2*MZ**2 - 48*cw**2*MT**4*MZ**2 - 60*MT**2*MW**2*MZ**2 + 9*cw**2*MT**2*MZ**4 + 12*MW**2*MZ**4 + 32*MT**4*MW**2*sw**2 + 96*MT**2*MW**2*MZ**2*sw**2 - 32*MW**2*MZ**4*sw**2 - 128*MT**4*MW**2*sw**4 - 64*MT**2*MW**2*MZ**2*sw**4 + 32*MW**2*MZ**4*sw**4)*reglog((MT**2 + vep*complex(0,-1))/MU_R**2))/(384.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (ee**2*(MT - MW)*(MT + MW)*(MT**4 + MT**2*MW**2 + 4*MW**4)*reglog((-MT**2 + MW**2 + vep*complex(0,-1))/MW**2))/(64.*MT**4*MW**2*cmath.pi**2*sw**2) + (ee**2*(-60*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 60*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 12*MW**2*MZ**4 - 32*MT**4*MW**2*sw**2 - 96*MT**2*MW**2*MZ**2*sw**2 + 32*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2.*MT**2)))/(384.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (ee**2*(-60*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 60*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 12*MW**2*MZ**4 - 32*MT**4*MW**2*sw**2 - 96*MT**2*MW**2*MZ**2*sw**2 + 32*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2.*MT**2)))/(384.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) - (ee**2*(-60*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 60*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 12*MW**2*MZ**4 - 32*MT**4*MW**2*sw**2 - 96*MT**2*MW**2*MZ**2*sw**2 + 32*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*(2*MT**2 - MZ**2 + cmath.sqrt(-4*MT**2*MZ**2 + MZ**4 + MT**2*vep*complex(0,4)))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2*MT**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MT**4*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (ee**2*(-60*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 60*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 12*MW**2*MZ**4 - 32*MT**4*MW**2*sw**2 - 96*MT**2*MW**2*MZ**2*sw**2 + 32*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*(-2*MT**2 + MZ**2 + cmath.sqrt(-4*MT**2*MZ**2 + MZ**4 + MT**2*vep*complex(0,4)))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(-2*MT**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MT**4*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (3*ee**2*(MH**2 - 2*MT**2)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MT**2*(MH**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MW**2*cmath.pi**2*sw**2) + (3*ee**2*(MH**2 - 2*MT**2)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MT**2*(MH**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MW**2*cmath.pi**2*sw**2) - (3*ee**2*(MH**2 - 2*MT**2)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))*reglog((MH**2 - 2*MT**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))))/(256.*MT**2*MW**2*cmath.pi**2*sw**2) + (3*ee**2*(MH**2 - 2*MT**2)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MT**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))))/(256.*MT**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_tWcft_UV_EW_R.value[0]},
+                            value = {-1:'recms(CMSParam==1.0 and WT != 0,-(ee**2*(8*MW**2*sw**4 + 3*cw**2*(3*MT**2 + 8*MW**2*sw**2)))/(288.*cw**2*MW**2*cmath.pi**2*sw**2))',
+                            0:'recms(CMSParam==1.0 and WT != 0,-(ee**2*(27*cw**2*MH**2*MT**2 - 36*cw**2*MT**4 - 54*MT**2*MW**2 - 18*cw**2*MT**2*MW**2 + 72*cw**2*MW**4 + 27*cw**2*MT**2*MZ**2 + 36*MW**2*MZ**2 - 48*MT**2*MW**2*sw**2 + 128*cw**2*MT**2*MW**2*sw**2 - 96*MW**2*MZ**2*sw**2 + 128*MT**2*MW**2*sw**4 + 96*MW**2*MZ**2*sw**4 + 18*cw**2*MT**4*reglog(16) + 64*cw**2*MT**2*MW**2*sw**2*reglog(16) + 36*cw**2*MT**4*reglog(cmath.pi) + 128*cw**2*MT**2*MW**2*sw**2*reglog(cmath.pi) - 36*cw**2*MT**4*reglog(4*cmath.pi) - 128*cw**2*MT**2*MW**2*sw**2*reglog(4*cmath.pi)))/(1152.*cw**2*MT**2*MW**2*cmath.pi**2*sw**2) + (ee**2*(3*MH**2 - 4*MT**2)*reglog(MU_R**2/MH**2))/(128.*MW**2*cmath.pi**2*sw**2) - (ee**2*(24*cw**2*MT**4 + 18*MT**2*MW**2 - 9*cw**2*MT**2*MZ**2 - 6*MW**2*MZ**2 - 16*MT**2*MW**2*sw**2 + 64*cw**2*MT**2*MW**2*sw**2 + 16*MW**2*MZ**2*sw**2 - 16*cw**2*MW**2*MZ**2*sw**2 - 16*MW**2*MZ**2*sw**4)*reglog(MU_R**2/MT**2))/(192.*cw**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) - (ee**2*MT**2*reglog(MU_R**2/MW**2))/(64.*MW**2*cmath.pi**2*sw**2) + (ee**2*(-72*MT**4*MW**2 + 72*cw**2*MT**4*MZ**2 + 144*MT**2*MW**2*MZ**2 - 27*cw**2*MT**2*MZ**4 - 36*MW**2*MZ**4 - 192*MT**4*MW**2*sw**2 - 192*MT**2*MW**2*MZ**2*sw**2 + 96*MW**2*MZ**4*sw**2 + 256*MT**4*MW**2*sw**4 + 128*MT**2*MW**2*MZ**2*sw**4 - 96*MW**2*MZ**4*sw**4)*reglog(MU_R**2/MZ**2))/(1152.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) - (ee**2*(-36*cw**2*MH**2*MT**4 + 72*cw**2*MT**6 + 60*MT**4*MW**2 + 9*cw**2*MH**2*MT**2*MZ**2 - 48*cw**2*MT**4*MZ**2 - 60*MT**2*MW**2*MZ**2 + 9*cw**2*MT**2*MZ**4 + 12*MW**2*MZ**4 + 32*MT**4*MW**2*sw**2 + 96*MT**2*MW**2*MZ**2*sw**2 - 32*MW**2*MZ**4*sw**2 - 128*MT**4*MW**2*sw**4 - 64*MT**2*MW**2*MZ**2*sw**4 + 32*MW**2*MZ**4*sw**4)*reglog((MT**2 + vep*complex(0,-1))/MU_R**2))/(384.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (ee**2*(MT - MW)*(MT + MW)*(MT**4 + MT**2*MW**2 + 4*MW**4)*reglogm((-MT**2 + MW**2 + vep*complex(0,-1))/MW**2))/(64.*MT**4*MW**2*cmath.pi**2*sw**2) + (ee**2*(-60*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 60*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 12*MW**2*MZ**4 - 32*MT**4*MW**2*sw**2 - 96*MT**2*MW**2*MZ**2*sw**2 + 32*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2.*MT**2)))/(384.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (ee**2*(-60*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 60*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 12*MW**2*MZ**4 - 32*MT**4*MW**2*sw**2 - 96*MT**2*MW**2*MZ**2*sw**2 + 32*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2.*MT**2)))/(384.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) - (ee**2*(-60*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 60*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 12*MW**2*MZ**4 - 32*MT**4*MW**2*sw**2 - 96*MT**2*MW**2*MZ**2*sw**2 + 32*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*(2*MT**2 - MZ**2 + cmath.sqrt(-4*MT**2*MZ**2 + MZ**4 + MT**2*vep*complex(0,4)))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2*MT**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MT**4*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (ee**2*(-60*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 60*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 12*MW**2*MZ**4 - 32*MT**4*MW**2*sw**2 - 96*MT**2*MW**2*MZ**2*sw**2 + 32*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*(-2*MT**2 + MZ**2 + cmath.sqrt(-4*MT**2*MZ**2 + MZ**4 + MT**2*vep*complex(0,4)))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(-2*MT**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MT**4*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (3*ee**2*(MH**2 - 2*MT**2)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MT**2*(MH**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MW**2*cmath.pi**2*sw**2) + (3*ee**2*(MH**2 - 2*MT**2)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MT**2*(MH**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MW**2*cmath.pi**2*sw**2) - (3*ee**2*(MH**2 - 2*MT**2)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))*reglog((MH**2 - 2*MT**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))))/(256.*MT**2*MW**2*cmath.pi**2*sw**2) + (3*ee**2*(MH**2 - 2*MT**2)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MT**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))))/(256.*MT**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_tWcft_UV_EW_R.value[0]},
                             texname = '\delta ZR_t^{EW}')
 
 
@@ -352,181 +359,181 @@
 
 cWcft_UV_EW_R = CTParameter(name = 'cWcft_UV_EW_R',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*sw**2)/(36.*cw**2*cmath.pi**2))',
-                                      0:'re(-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(72.*cw**2*cmath.pi**2))'},
+                            value = {-1:'recms(CMSParam==1.0,-(ee**2*sw**2)/(36.*cw**2*cmath.pi**2))',
+                                      0:'recms(CMSParam==1.0,-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(72.*cw**2*cmath.pi**2))'},
                             texname = '\delta ZR_c^{EW}')
 
 
 uWcft_UV_EW_R = CTParameter(name = 'uWcft_UV_EW_R',
                            type = 'complex',
-                           value = {-1:'re(-(ee**2*sw**2)/(36.*cw**2*cmath.pi**2))',
-                                     0:'re(-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(72.*cw**2*cmath.pi**2))'},
+                           value = {-1:'recms(CMSParam==1.0,-(ee**2*sw**2)/(36.*cw**2*cmath.pi**2))',
+                                     0:'recms(CMSParam==1.0,-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(72.*cw**2*cmath.pi**2))'},
                            texname = '\delta ZR_u^{EW}')
 
 
 
 bWcft_UV_EW_R = CTParameter(name = 'bWcft_UV_EW_R',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*sw**2)/(144.*cw**2*cmath.pi**2))'+'+'+dMB_bWcft_UV_EW_R.value[-1],
-                                      0:'re(-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(288.*cw**2*cmath.pi**2))'+'+'+dMB_bWcft_UV_EW_R.value[0]},
+                            value = {-1:'recms(CMSParam==1.0,-(ee**2*sw**2)/(144.*cw**2*cmath.pi**2))'+'+'+dMB_bWcft_UV_EW_R.value[-1],
+                                      0:'recms(CMSParam==1.0,-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(288.*cw**2*cmath.pi**2))'+'+'+dMB_bWcft_UV_EW_R.value[0]},
                             texname = '\delta ZR_b^{EW}')
 
 
 sWcft_UV_EW_R = CTParameter(name = 'sWcft_UV_EW_R',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*sw**2)/(144.*cw**2*cmath.pi**2))',
-                                      0:'re(-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(288.*cw**2*cmath.pi**2))'},
+                            value = {-1:'recms(CMSParam==1.0,-(ee**2*sw**2)/(144.*cw**2*cmath.pi**2))',
+                                      0:'recms(CMSParam==1.0,-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(288.*cw**2*cmath.pi**2))'},
                             texname = '\delta ZR_s^{EW}')
 
 
 dWcft_UV_EW_R = CTParameter(name = 'dWcft_UV_EW_R',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*sw**2)/(144.*cw**2*cmath.pi**2))',
-                                      0:'re(-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(288.*cw**2*cmath.pi**2))'},
+                            value = {-1:'recms(CMSParam==1.0,-(ee**2*sw**2)/(144.*cw**2*cmath.pi**2))',
+                                      0:'recms(CMSParam==1.0,-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(288.*cw**2*cmath.pi**2))'},
                             texname = '\delta ZR_d^{EW}')
 
 
 tauWcft_UV_EW_R = CTParameter(name = 'tauWcft_UV_EW_R',
                               type = 'complex',
-                              value = {-1:'re(-(ee**2*sw**2)/(16.*cw**2*cmath.pi**2))',
-                                        0:'re(-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(32.*cw**2*cmath.pi**2))'},
+                              value = {-1:'recms(CMSParam==1.0,-(ee**2*sw**2)/(16.*cw**2*cmath.pi**2))',
+                                        0:'recms(CMSParam==1.0,-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(32.*cw**2*cmath.pi**2))'},
                               texname = '\delta ZR_tau^{EW}')
 
 
 muWcft_UV_EW_R = CTParameter(name = 'muWcft_UV_EW_R',
                              type = 'complex',
-                             value = {-1:'re(-(ee**2*sw**2)/(16.*cw**2*cmath.pi**2))',
-                                       0:'re(-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(32.*cw**2*cmath.pi**2))'},
+                             value = {-1:'recms(CMSParam==1.0,-(ee**2*sw**2)/(16.*cw**2*cmath.pi**2))',
+                                       0:'recms(CMSParam==1.0,-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(32.*cw**2*cmath.pi**2))'},
                              texname = '\delta ZR_mu^{EW}')
 
 
 eWcft_UV_EW_R = CTParameter(name = 'eWcft_UV_EW_R',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*sw**2)/(16.*cw**2*cmath.pi**2))',
-                                      0:'re(-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(32.*cw**2*cmath.pi**2))'},
+                            value = {-1:'recms(CMSParam==1.0,-(ee**2*sw**2)/(16.*cw**2*cmath.pi**2))',
+                                      0:'recms(CMSParam==1.0,-(ee**2*sw**2*(-1 + 2*reglog(MU_R**2/MZ**2)))/(32.*cw**2*cmath.pi**2))'},
                             texname = '\delta ZR_e^{EW}')
 
 tWcft_UV_EW_L = CTParameter(name = 'tWcft_UV_EW_L',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*(MW**2*(3 - 4*sw**2)**2 + 3*cw**2*(3*MT**2 + 2*MW**2*(3 + 8*sw**2))))/(576.*cw**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_tWcft_UV_EW_L.value[-1],
-                            0:'re((ee**2*(-27*cw**2*MH**2*MT**2 + 72*cw**2*MT**4 + 18*MT**2*MW**2 - 36*cw**2*MT**2*MW**2 - 36*cw**2*MW**4 - 27*cw**2*MT**2*MZ**2 - 18*MW**2*MZ**2 + 144*MT**2*MW**2*sw**2 - 128*cw**2*MT**2*MW**2*sw**2 + 48*MW**2*MZ**2*sw**2 - 128*MT**2*MW**2*sw**4 - 96*MW**2*MZ**2*sw**4 - 64*cw**2*MT**2*MW**2*sw**2*reglog(16) + 18*cw**2*MT**4*reglog(1/(4.*cmath.pi)) + 18*MT**2*MW**2*reglog(1/(4.*cmath.pi)) - 48*MT**2*MW**2*sw**2*reglog(1/(4.*cmath.pi)) + 32*MT**2*MW**2*sw**4*reglog(1/(4.*cmath.pi)) - 160*cw**2*MT**2*MW**2*sw**2*reglog(cmath.pi) + 64*cw**2*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 18*cw**2*MT**4*reglog(4*cmath.pi) + 18*MT**2*MW**2*reglog(4*cmath.pi) - 48*MT**2*MW**2*sw**2*reglog(4*cmath.pi) + 96*cw**2*MT**2*MW**2*sw**2*reglog(4*cmath.pi) + 32*MT**2*MW**2*sw**4*reglog(4*cmath.pi)))/(1152.*cw**2*MT**2*MW**2*cmath.pi**2*sw**2) + (ee**2*(3*MH**2 - 4*MT**2)*reglog(MU_R**2/MH**2))/(128.*MW**2*cmath.pi**2*sw**2) - (ee**2*(24*cw**2*MT**4 + 6*MT**2*MW**2 - 9*cw**2*MT**2*MZ**2 - 3*MW**2*MZ**2 + 16*MT**2*MW**2*sw**2 + 64*cw**2*MT**2*MW**2*sw**2 + 8*MW**2*MZ**2*sw**2 - 16*cw**2*MW**2*MZ**2*sw**2 - 16*MW**2*MZ**2*sw**4)*reglog(MU_R**2/MT**2))/(192.*cw**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) - (ee**2*reglog(MU_R**2/MW**2))/(32.*cmath.pi**2*sw**2) + (ee**2*(-72*MT**4*MW**2 + 72*cw**2*MT**4*MZ**2 + 72*MT**2*MW**2*MZ**2 - 27*cw**2*MT**2*MZ**4 - 18*MW**2*MZ**4 - 192*MT**4*MW**2*sw**2 + 48*MW**2*MZ**4*sw**2 + 256*MT**4*MW**2*sw**4 + 128*MT**2*MW**2*MZ**2*sw**4 - 96*MW**2*MZ**4*sw**4)*reglog(MU_R**2/MZ**2))/(1152.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) - (ee**2*(-36*cw**2*MH**2*MT**4 + 72*cw**2*MT**6 + 12*MT**4*MW**2 + 9*cw**2*MH**2*MT**2*MZ**2 - 48*cw**2*MT**4*MZ**2 - 24*MT**2*MW**2*MZ**2 + 9*cw**2*MT**2*MZ**4 + 6*MW**2*MZ**4 + 160*MT**4*MW**2*sw**2 - 16*MW**2*MZ**4*sw**2 - 128*MT**4*MW**2*sw**4 - 64*MT**2*MW**2*MZ**2*sw**4 + 32*MW**2*MZ**4*sw**4)*reglog((MT**2 + vep*complex(0,-1))/MU_R**2))/(384.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (ee**2*(MT - MW)*(MT + MW)*(2*MT**2 + MW**2)*reglog((-MT**2 + MW**2 + vep*complex(0,-1))/MW**2))/(32.*MT**4*cmath.pi**2*sw**2) + (ee**2*(-12*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 24*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 6*MW**2*MZ**4 - 160*MT**4*MW**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2.*MT**2)))/(384.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (ee**2*(-12*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 24*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 6*MW**2*MZ**4 - 160*MT**4*MW**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2.*MT**2)))/(384.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) - (ee**2*(-12*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 24*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 6*MW**2*MZ**4 - 160*MT**4*MW**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*(2*MT**2 - MZ**2 + cmath.sqrt(-4*MT**2*MZ**2 + MZ**4 + MT**2*vep*complex(0,4)))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2*MT**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MT**4*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (ee**2*(-12*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 24*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 6*MW**2*MZ**4 - 160*MT**4*MW**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*(-2*MT**2 + MZ**2 + cmath.sqrt(-4*MT**2*MZ**2 + MZ**4 + MT**2*vep*complex(0,4)))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(-2*MT**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MT**4*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (3*ee**2*(MH**2 - 2*MT**2)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MT**2*(MH**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MW**2*cmath.pi**2*sw**2) + (3*ee**2*(MH**2 - 2*MT**2)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MT**2*(MH**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MW**2*cmath.pi**2*sw**2) - (3*ee**2*(MH**2 - 2*MT**2)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))*reglog((MH**2 - 2*MT**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))))/(256.*MT**2*MW**2*cmath.pi**2*sw**2) + (3*ee**2*(MH**2 - 2*MT**2)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MT**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))))/(256.*MT**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_tWcft_UV_EW_L.value[0]},
+                            value = {-1:'recms(CMSParam==1.0 and WT != 0,-(ee**2*(MW**2*(3 - 4*sw**2)**2 + 3*cw**2*(3*MT**2 + 2*MW**2*(3 + 8*sw**2))))/(576.*cw**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_tWcft_UV_EW_L.value[-1],
+                            0:'recms(CMSParam==1.0 and WT != 0,(ee**2*(-27*cw**2*MH**2*MT**2 + 72*cw**2*MT**4 + 18*MT**2*MW**2 - 36*cw**2*MT**2*MW**2 - 36*cw**2*MW**4 - 27*cw**2*MT**2*MZ**2 - 18*MW**2*MZ**2 + 144*MT**2*MW**2*sw**2 - 128*cw**2*MT**2*MW**2*sw**2 + 48*MW**2*MZ**2*sw**2 - 128*MT**2*MW**2*sw**4 - 96*MW**2*MZ**2*sw**4 - 64*cw**2*MT**2*MW**2*sw**2*reglog(16) + 18*cw**2*MT**4*reglog(1/(4.*cmath.pi)) + 18*MT**2*MW**2*reglog(1/(4.*cmath.pi)) - 48*MT**2*MW**2*sw**2*reglog(1/(4.*cmath.pi)) + 32*MT**2*MW**2*sw**4*reglog(1/(4.*cmath.pi)) - 160*cw**2*MT**2*MW**2*sw**2*reglog(cmath.pi) + 64*cw**2*MT**2*MW**2*sw**2*reglog(2*cmath.pi) + 18*cw**2*MT**4*reglog(4*cmath.pi) + 18*MT**2*MW**2*reglog(4*cmath.pi) - 48*MT**2*MW**2*sw**2*reglog(4*cmath.pi) + 96*cw**2*MT**2*MW**2*sw**2*reglog(4*cmath.pi) + 32*MT**2*MW**2*sw**4*reglog(4*cmath.pi)))/(1152.*cw**2*MT**2*MW**2*cmath.pi**2*sw**2) + (ee**2*(3*MH**2 - 4*MT**2)*reglog(MU_R**2/MH**2))/(128.*MW**2*cmath.pi**2*sw**2) - (ee**2*(24*cw**2*MT**4 + 6*MT**2*MW**2 - 9*cw**2*MT**2*MZ**2 - 3*MW**2*MZ**2 + 16*MT**2*MW**2*sw**2 + 64*cw**2*MT**2*MW**2*sw**2 + 8*MW**2*MZ**2*sw**2 - 16*cw**2*MW**2*MZ**2*sw**2 - 16*MW**2*MZ**2*sw**4)*reglog(MU_R**2/MT**2))/(192.*cw**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) - (ee**2*reglog(MU_R**2/MW**2))/(32.*cmath.pi**2*sw**2) + (ee**2*(-72*MT**4*MW**2 + 72*cw**2*MT**4*MZ**2 + 72*MT**2*MW**2*MZ**2 - 27*cw**2*MT**2*MZ**4 - 18*MW**2*MZ**4 - 192*MT**4*MW**2*sw**2 + 48*MW**2*MZ**4*sw**2 + 256*MT**4*MW**2*sw**4 + 128*MT**2*MW**2*MZ**2*sw**4 - 96*MW**2*MZ**4*sw**4)*reglog(MU_R**2/MZ**2))/(1152.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) - (ee**2*(-36*cw**2*MH**2*MT**4 + 72*cw**2*MT**6 + 12*MT**4*MW**2 + 9*cw**2*MH**2*MT**2*MZ**2 - 48*cw**2*MT**4*MZ**2 - 24*MT**2*MW**2*MZ**2 + 9*cw**2*MT**2*MZ**4 + 6*MW**2*MZ**4 + 160*MT**4*MW**2*sw**2 - 16*MW**2*MZ**4*sw**2 - 128*MT**4*MW**2*sw**4 - 64*MT**2*MW**2*MZ**2*sw**4 + 32*MW**2*MZ**4*sw**4)*reglog((MT**2 + vep*complex(0,-1))/MU_R**2))/(384.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (ee**2*(MT - MW)*(MT + MW)*(2*MT**2 + MW**2)*reglogm((-MT**2 + MW**2 + vep*complex(0,-1))/MW**2))/(32.*MT**4*cmath.pi**2*sw**2) + (ee**2*(-12*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 24*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 6*MW**2*MZ**4 - 160*MT**4*MW**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2.*MT**2)))/(384.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (ee**2*(-12*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 24*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 6*MW**2*MZ**4 - 160*MT**4*MW**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2.*MT**2)))/(384.*cw**2*MT**2*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) - (ee**2*(-12*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 24*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 6*MW**2*MZ**4 - 160*MT**4*MW**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*(2*MT**2 - MZ**2 + cmath.sqrt(-4*MT**2*MZ**2 + MZ**4 + MT**2*vep*complex(0,4)))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(2*MT**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MT**4*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (ee**2*(-12*MT**4*MW**2 + 30*cw**2*MT**4*MZ**2 + 24*MT**2*MW**2*MZ**2 - 9*cw**2*MT**2*MZ**4 - 6*MW**2*MZ**4 - 160*MT**4*MW**2*sw**2 + 16*MW**2*MZ**4*sw**2 + 128*MT**4*MW**2*sw**4 + 64*MT**2*MW**2*MZ**2*sw**4 - 32*MW**2*MZ**4*sw**4)*(-2*MT**2 + MZ**2 + cmath.sqrt(-4*MT**2*MZ**2 + MZ**4 + MT**2*vep*complex(0,4)))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))/(-2*MT**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MT**2*(MZ**2 + vep*complex(0,-1))))))/(768.*cw**2*MT**4*MW**2*(2*MT - MZ)*(2*MT + MZ)*cmath.pi**2*sw**2) + (3*ee**2*(MH**2 - 2*MT**2)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MT**2*(MH**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MW**2*cmath.pi**2*sw**2) + (3*ee**2*(MH**2 - 2*MT**2)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MT**2*(MH**2 + vep*complex(0,-1))))/(2.*MT**2)))/(128.*MW**2*cmath.pi**2*sw**2) - (3*ee**2*(MH**2 - 2*MT**2)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))*reglog((MH**2 - 2*MT**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))))/(256.*MT**2*MW**2*cmath.pi**2*sw**2) + (3*ee**2*(MH**2 - 2*MT**2)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MT**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MT**2 + MT**2*vep*complex(0,4)))))/(256.*MT**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_tWcft_UV_EW_L.value[0]},
                             texname = '\delta ZL_t^{EW}')
 
 
 cWcft_UV_EW_L = CTParameter(name = 'cWcft_UV_EW_L',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*(18*cw**2 + (3 - 4*sw**2)**2))/(576.*cw**2*cmath.pi**2*sw**2))',
-                                      0:'re(-(ee**2*(-9 - 18*cw**2 + 24*sw**2 - 16*sw**4 + 36*cw**2*reglog(MU_R**2/MW**2) + 2*(3 - 4*sw**2)**2*reglog(MU_R**2/MZ**2)))/(1152.*cw**2*cmath.pi**2*sw**2))'},
+                            value = {-1:'recms(CMSParam==1.0,-(ee**2*(18*cw**2 + (3 - 4*sw**2)**2))/(576.*cw**2*cmath.pi**2*sw**2))',
+                                      0:'recms(CMSParam==1.0,-(ee**2*(-9 - 18*cw**2 + 24*sw**2 - 16*sw**4 + 36*cw**2*reglog(MU_R**2/MW**2) + 2*(3 - 4*sw**2)**2*reglog(MU_R**2/MZ**2)))/(1152.*cw**2*cmath.pi**2*sw**2))'},
                             texname = '\delta ZL_c^{EW}')
 
 
 uWcft_UV_EW_L = CTParameter(name = 'uWcft_UV_EW_L',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*(18*cw**2 + (3 - 4*sw**2)**2))/(576.*cw**2*cmath.pi**2*sw**2))',
-                                      0:'re(-(ee**2*(-9 - 18*cw**2 + 24*sw**2 - 16*sw**4 + 36*cw**2*reglog(MU_R**2/MW**2) + 2*(3 - 4*sw**2)**2*reglog(MU_R**2/MZ**2)))/(1152.*cw**2*cmath.pi**2*sw**2))'},
+                            value = {-1:'recms(CMSParam==1.0,-(ee**2*(18*cw**2 + (3 - 4*sw**2)**2))/(576.*cw**2*cmath.pi**2*sw**2))',
+                                      0:'recms(CMSParam==1.0,-(ee**2*(-9 - 18*cw**2 + 24*sw**2 - 16*sw**4 + 36*cw**2*reglog(MU_R**2/MW**2) + 2*(3 - 4*sw**2)**2*reglog(MU_R**2/MZ**2)))/(1152.*cw**2*cmath.pi**2*sw**2))'},
                             texname = '\delta ZL_u^{EW}')
 
 
 
 bWcft_UV_EW_L = CTParameter(name = 'bWcft_UV_EW_L',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*(MW**2*(18*cw**2 + (3 - 2*sw**2)**2) + 9*cw**2*MT**2*CKM33*complexconjugate(CKM33)))/(576.*cw**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_bWcft_UV_EW_L.value[-1],
-                                      0:'re(-(ee**2*(-9*MT**2*MW**2 - 18*cw**2*MT**2*MW**2 + 9*MW**4 + 18*cw**2*MW**4 + 12*MT**2*MW**2*sw**2 - 12*MW**4*sw**2 - 4*MT**2*MW**2*sw**4 + 4*MW**4*sw**4 + 27*cw**2*MT**4*CKM33*complexconjugate(CKM33) + 27*cw**2*MT**2*MW**2*CKM33*complexconjugate(CKM33) + 9*MT**2*MW**2*reglog(16) + 18*cw**2*MT**2*MW**2*reglog(16) - 9*MW**4*reglog(16) - 18*cw**2*MW**4*reglog(16) - 12*MT**2*MW**2*sw**2*reglog(16) + 12*MW**4*sw**2*reglog(16) + 4*MT**2*MW**2*sw**4*reglog(16) - 4*MW**4*sw**4*reglog(16) + 9*cw**2*MT**4*CKM33*complexconjugate(CKM33)*reglog(16) - 9*cw**2*MT**2*MW**2*CKM33*complexconjugate(CKM33)*reglog(16) + 18*MT**2*MW**2*reglog(cmath.pi) + 36*cw**2*MT**2*MW**2*reglog(cmath.pi) - 18*MW**4*reglog(cmath.pi) - 36*cw**2*MW**4*reglog(cmath.pi) - 24*MT**2*MW**2*sw**2*reglog(cmath.pi) + 24*MW**4*sw**2*reglog(cmath.pi) + 8*MT**2*MW**2*sw**4*reglog(cmath.pi) - 8*MW**4*sw**4*reglog(cmath.pi) + 18*cw**2*MT**4*CKM33*complexconjugate(CKM33)*reglog(cmath.pi) - 18*cw**2*MT**2*MW**2*CKM33*complexconjugate(CKM33)*reglog(cmath.pi) - 18*MT**2*MW**2*reglog(4*cmath.pi) - 36*cw**2*MT**2*MW**2*reglog(4*cmath.pi) + 18*MW**4*reglog(4*cmath.pi) + 36*cw**2*MW**4*reglog(4*cmath.pi) + 24*MT**2*MW**2*sw**2*reglog(4*cmath.pi) - 24*MW**4*sw**2*reglog(4*cmath.pi) - 8*MT**2*MW**2*sw**4*reglog(4*cmath.pi) + 8*MW**4*sw**4*reglog(4*cmath.pi) - 18*cw**2*MT**4*CKM33*complexconjugate(CKM33)*reglog(4*cmath.pi) + 18*cw**2*MT**2*MW**2*CKM33*complexconjugate(CKM33)*reglog(4*cmath.pi)))/(1152.*cw**2*(MT - MW)*MW**2*(MT + MW)*cmath.pi**2*sw**2) - (ee**2*MT**4*(MT**2 + 2*MW**2)*CKM33*complexconjugate(CKM33)*reglog(MU_R**2/MT**2))/(64.*(MT - MW)**2*MW**2*(MT + MW)**2*cmath.pi**2*sw**2) + (ee**2*(-2*MT**4 + 4*MT**2*MW**2 - 2*MW**4 + 4*MT**4*CKM33*complexconjugate(CKM33) - MT**2*MW**2*CKM33*complexconjugate(CKM33))*reglog(MU_R**2/MW**2))/(64.*(MT - MW)**2*(MT + MW)**2*cmath.pi**2*sw**2) - (ee**2*(-3 + 2*sw**2)**2*reglog(MU_R**2/MZ**2))/(576.*cw**2*cmath.pi**2*sw**2))'+'+'+dMB_bWcft_UV_EW_L.value[0]},
+                            value = {-1:'recms(CMSParam==1.0,-(ee**2*(MW**2*(18*cw**2 + (3 - 2*sw**2)**2) + 9*cw**2*MT**2*CKM33*complexconjugate(CKM33)))/(576.*cw**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_bWcft_UV_EW_L.value[-1],
+                                      0:'recms(CMSParam==1.0,-(ee**2*(-9*MT**2*MW**2 - 18*cw**2*MT**2*MW**2 + 9*MW**4 + 18*cw**2*MW**4 + 12*MT**2*MW**2*sw**2 - 12*MW**4*sw**2 - 4*MT**2*MW**2*sw**4 + 4*MW**4*sw**4 + 27*cw**2*MT**4*CKM33*complexconjugate(CKM33) + 27*cw**2*MT**2*MW**2*CKM33*complexconjugate(CKM33) + 9*MT**2*MW**2*reglog(16) + 18*cw**2*MT**2*MW**2*reglog(16) - 9*MW**4*reglog(16) - 18*cw**2*MW**4*reglog(16) - 12*MT**2*MW**2*sw**2*reglog(16) + 12*MW**4*sw**2*reglog(16) + 4*MT**2*MW**2*sw**4*reglog(16) - 4*MW**4*sw**4*reglog(16) + 9*cw**2*MT**4*CKM33*complexconjugate(CKM33)*reglog(16) - 9*cw**2*MT**2*MW**2*CKM33*complexconjugate(CKM33)*reglog(16) + 18*MT**2*MW**2*reglog(cmath.pi) + 36*cw**2*MT**2*MW**2*reglog(cmath.pi) - 18*MW**4*reglog(cmath.pi) - 36*cw**2*MW**4*reglog(cmath.pi) - 24*MT**2*MW**2*sw**2*reglog(cmath.pi) + 24*MW**4*sw**2*reglog(cmath.pi) + 8*MT**2*MW**2*sw**4*reglog(cmath.pi) - 8*MW**4*sw**4*reglog(cmath.pi) + 18*cw**2*MT**4*CKM33*complexconjugate(CKM33)*reglog(cmath.pi) - 18*cw**2*MT**2*MW**2*CKM33*complexconjugate(CKM33)*reglog(cmath.pi) - 18*MT**2*MW**2*reglog(4*cmath.pi) - 36*cw**2*MT**2*MW**2*reglog(4*cmath.pi) + 18*MW**4*reglog(4*cmath.pi) + 36*cw**2*MW**4*reglog(4*cmath.pi) + 24*MT**2*MW**2*sw**2*reglog(4*cmath.pi) - 24*MW**4*sw**2*reglog(4*cmath.pi) - 8*MT**2*MW**2*sw**4*reglog(4*cmath.pi) + 8*MW**4*sw**4*reglog(4*cmath.pi) - 18*cw**2*MT**4*CKM33*complexconjugate(CKM33)*reglog(4*cmath.pi) + 18*cw**2*MT**2*MW**2*CKM33*complexconjugate(CKM33)*reglog(4*cmath.pi)))/(1152.*cw**2*(MT - MW)*MW**2*(MT + MW)*cmath.pi**2*sw**2) - (ee**2*MT**4*(MT**2 + 2*MW**2)*CKM33*complexconjugate(CKM33)*reglog(MU_R**2/MT**2))/(64.*(MT - MW)**2*MW**2*(MT + MW)**2*cmath.pi**2*sw**2) + (ee**2*(-2*MT**4 + 4*MT**2*MW**2 - 2*MW**4 + 4*MT**4*CKM33*complexconjugate(CKM33) - MT**2*MW**2*CKM33*complexconjugate(CKM33))*reglog(MU_R**2/MW**2))/(64.*(MT - MW)**2*(MT + MW)**2*cmath.pi**2*sw**2) - (ee**2*(-3 + 2*sw**2)**2*reglog(MU_R**2/MZ**2))/(576.*cw**2*cmath.pi**2*sw**2))'+'+'+dMB_bWcft_UV_EW_L.value[0]},
                             texname = '\delta ZL_b^{EW}')
 
 
 sWcft_UV_EW_L = CTParameter(name = 'sWcft_UV_EW_L',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*(MW**2*(18*cw**2 + (3 - 2*sw**2)**2) + 9*cw**2*MT**2*CKM32*complexconjugate(CKM32)))/(576.*cw**2*MW**2*cmath.pi**2*sw**2))',
-                                      0:'re(-(ee**2*(-9*MT**2*MW**2 - 18*cw**2*MT**2*MW**2 + 9*MW**4 + 18*cw**2*MW**4 + 12*MT**2*MW**2*sw**2 - 12*MW**4*sw**2 - 4*MT**2*MW**2*sw**4 + 4*MW**4*sw**4 + 27*cw**2*MT**4*CKM32*complexconjugate(CKM32) + 27*cw**2*MT**2*MW**2*CKM32*complexconjugate(CKM32) + 9*MT**2*MW**2*reglog(16) + 18*cw**2*MT**2*MW**2*reglog(16) - 9*MW**4*reglog(16) - 18*cw**2*MW**4*reglog(16) - 12*MT**2*MW**2*sw**2*reglog(16) + 12*MW**4*sw**2*reglog(16) + 4*MT**2*MW**2*sw**4*reglog(16) - 4*MW**4*sw**4*reglog(16) + 9*cw**2*MT**4*CKM32*complexconjugate(CKM32)*reglog(16) - 9*cw**2*MT**2*MW**2*CKM32*complexconjugate(CKM32)*reglog(16) + 18*MT**2*MW**2*reglog(cmath.pi) + 36*cw**2*MT**2*MW**2*reglog(cmath.pi) - 18*MW**4*reglog(cmath.pi) - 36*cw**2*MW**4*reglog(cmath.pi) - 24*MT**2*MW**2*sw**2*reglog(cmath.pi) + 24*MW**4*sw**2*reglog(cmath.pi) + 8*MT**2*MW**2*sw**4*reglog(cmath.pi) - 8*MW**4*sw**4*reglog(cmath.pi) + 18*cw**2*MT**4*CKM32*complexconjugate(CKM32)*reglog(cmath.pi) - 18*cw**2*MT**2*MW**2*CKM32*complexconjugate(CKM32)*reglog(cmath.pi) - 18*MT**2*MW**2*reglog(4*cmath.pi) - 36*cw**2*MT**2*MW**2*reglog(4*cmath.pi) + 18*MW**4*reglog(4*cmath.pi) + 36*cw**2*MW**4*reglog(4*cmath.pi) + 24*MT**2*MW**2*sw**2*reglog(4*cmath.pi) - 24*MW**4*sw**2*reglog(4*cmath.pi) - 8*MT**2*MW**2*sw**4*reglog(4*cmath.pi) + 8*MW**4*sw**4*reglog(4*cmath.pi) - 18*cw**2*MT**4*CKM32*complexconjugate(CKM32)*reglog(4*cmath.pi) + 18*cw**2*MT**2*MW**2*CKM32*complexconjugate(CKM32)*reglog(4*cmath.pi)))/(1152.*cw**2*(MT - MW)*MW**2*(MT + MW)*cmath.pi**2*sw**2) - (ee**2*MT**4*(MT**2 + 2*MW**2)*CKM32*complexconjugate(CKM32)*reglog(MU_R**2/MT**2))/(64.*(MT - MW)**2*MW**2*(MT + MW)**2*cmath.pi**2*sw**2) + (ee**2*(-2*MT**4 + 4*MT**2*MW**2 - 2*MW**4 + 4*MT**4*CKM32*complexconjugate(CKM32) - MT**2*MW**2*CKM32*complexconjugate(CKM32))*reglog(MU_R**2/MW**2))/(64.*(MT - MW)**2*(MT + MW)**2*cmath.pi**2*sw**2) - (ee**2*(-3 + 2*sw**2)**2*reglog(MU_R**2/MZ**2))/(576.*cw**2*cmath.pi**2*sw**2))'},
+                            value = {-1:'recms(CMSParam==1.0,-(ee**2*(MW**2*(18*cw**2 + (3 - 2*sw**2)**2) + 9*cw**2*MT**2*CKM32*complexconjugate(CKM32)))/(576.*cw**2*MW**2*cmath.pi**2*sw**2))',
+                                      0:'recms(CMSParam==1.0,-(ee**2*(-9*MT**2*MW**2 - 18*cw**2*MT**2*MW**2 + 9*MW**4 + 18*cw**2*MW**4 + 12*MT**2*MW**2*sw**2 - 12*MW**4*sw**2 - 4*MT**2*MW**2*sw**4 + 4*MW**4*sw**4 + 27*cw**2*MT**4*CKM32*complexconjugate(CKM32) + 27*cw**2*MT**2*MW**2*CKM32*complexconjugate(CKM32) + 9*MT**2*MW**2*reglog(16) + 18*cw**2*MT**2*MW**2*reglog(16) - 9*MW**4*reglog(16) - 18*cw**2*MW**4*reglog(16) - 12*MT**2*MW**2*sw**2*reglog(16) + 12*MW**4*sw**2*reglog(16) + 4*MT**2*MW**2*sw**4*reglog(16) - 4*MW**4*sw**4*reglog(16) + 9*cw**2*MT**4*CKM32*complexconjugate(CKM32)*reglog(16) - 9*cw**2*MT**2*MW**2*CKM32*complexconjugate(CKM32)*reglog(16) + 18*MT**2*MW**2*reglog(cmath.pi) + 36*cw**2*MT**2*MW**2*reglog(cmath.pi) - 18*MW**4*reglog(cmath.pi) - 36*cw**2*MW**4*reglog(cmath.pi) - 24*MT**2*MW**2*sw**2*reglog(cmath.pi) + 24*MW**4*sw**2*reglog(cmath.pi) + 8*MT**2*MW**2*sw**4*reglog(cmath.pi) - 8*MW**4*sw**4*reglog(cmath.pi) + 18*cw**2*MT**4*CKM32*complexconjugate(CKM32)*reglog(cmath.pi) - 18*cw**2*MT**2*MW**2*CKM32*complexconjugate(CKM32)*reglog(cmath.pi) - 18*MT**2*MW**2*reglog(4*cmath.pi) - 36*cw**2*MT**2*MW**2*reglog(4*cmath.pi) + 18*MW**4*reglog(4*cmath.pi) + 36*cw**2*MW**4*reglog(4*cmath.pi) + 24*MT**2*MW**2*sw**2*reglog(4*cmath.pi) - 24*MW**4*sw**2*reglog(4*cmath.pi) - 8*MT**2*MW**2*sw**4*reglog(4*cmath.pi) + 8*MW**4*sw**4*reglog(4*cmath.pi) - 18*cw**2*MT**4*CKM32*complexconjugate(CKM32)*reglog(4*cmath.pi) + 18*cw**2*MT**2*MW**2*CKM32*complexconjugate(CKM32)*reglog(4*cmath.pi)))/(1152.*cw**2*(MT - MW)*MW**2*(MT + MW)*cmath.pi**2*sw**2) - (ee**2*MT**4*(MT**2 + 2*MW**2)*CKM32*complexconjugate(CKM32)*reglog(MU_R**2/MT**2))/(64.*(MT - MW)**2*MW**2*(MT + MW)**2*cmath.pi**2*sw**2) + (ee**2*(-2*MT**4 + 4*MT**2*MW**2 - 2*MW**4 + 4*MT**4*CKM32*complexconjugate(CKM32) - MT**2*MW**2*CKM32*complexconjugate(CKM32))*reglog(MU_R**2/MW**2))/(64.*(MT - MW)**2*(MT + MW)**2*cmath.pi**2*sw**2) - (ee**2*(-3 + 2*sw**2)**2*reglog(MU_R**2/MZ**2))/(576.*cw**2*cmath.pi**2*sw**2))'},
                             texname = '\delta ZL_s^{EW}')
 
 
 dWcft_UV_EW_L = CTParameter(name = 'dWcft_UV_EW_L',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*(MW**2*(18*cw**2 + (3 - 2*sw**2)**2) + 9*cw**2*MT**2*CKM31*complexconjugate(CKM31)))/(576.*cw**2*MW**2*cmath.pi**2*sw**2))',
-                                      0:'re(-(ee**2*(-9*MT**2*MW**2 - 18*cw**2*MT**2*MW**2 + 9*MW**4 + 18*cw**2*MW**4 + 12*MT**2*MW**2*sw**2 - 12*MW**4*sw**2 - 4*MT**2*MW**2*sw**4 + 4*MW**4*sw**4 + 27*cw**2*MT**4*CKM31*complexconjugate(CKM31) + 27*cw**2*MT**2*MW**2*CKM31*complexconjugate(CKM31) + 9*MT**2*MW**2*reglog(16) + 18*cw**2*MT**2*MW**2*reglog(16) - 9*MW**4*reglog(16) - 18*cw**2*MW**4*reglog(16) - 12*MT**2*MW**2*sw**2*reglog(16) + 12*MW**4*sw**2*reglog(16) + 4*MT**2*MW**2*sw**4*reglog(16) - 4*MW**4*sw**4*reglog(16) + 9*cw**2*MT**4*CKM31*complexconjugate(CKM31)*reglog(16) - 9*cw**2*MT**2*MW**2*CKM31*complexconjugate(CKM31)*reglog(16) + 18*MT**2*MW**2*reglog(cmath.pi) + 36*cw**2*MT**2*MW**2*reglog(cmath.pi) - 18*MW**4*reglog(cmath.pi) - 36*cw**2*MW**4*reglog(cmath.pi) - 24*MT**2*MW**2*sw**2*reglog(cmath.pi) + 24*MW**4*sw**2*reglog(cmath.pi) + 8*MT**2*MW**2*sw**4*reglog(cmath.pi) - 8*MW**4*sw**4*reglog(cmath.pi) + 18*cw**2*MT**4*CKM31*complexconjugate(CKM31)*reglog(cmath.pi) - 18*cw**2*MT**2*MW**2*CKM31*complexconjugate(CKM31)*reglog(cmath.pi) - 18*MT**2*MW**2*reglog(4*cmath.pi) - 36*cw**2*MT**2*MW**2*reglog(4*cmath.pi) + 18*MW**4*reglog(4*cmath.pi) + 36*cw**2*MW**4*reglog(4*cmath.pi) + 24*MT**2*MW**2*sw**2*reglog(4*cmath.pi) - 24*MW**4*sw**2*reglog(4*cmath.pi) - 8*MT**2*MW**2*sw**4*reglog(4*cmath.pi) + 8*MW**4*sw**4*reglog(4*cmath.pi) - 18*cw**2*MT**4*CKM31*complexconjugate(CKM31)*reglog(4*cmath.pi) + 18*cw**2*MT**2*MW**2*CKM31*complexconjugate(CKM31)*reglog(4*cmath.pi)))/(1152.*cw**2*(MT - MW)*MW**2*(MT + MW)*cmath.pi**2*sw**2) - (ee**2*MT**4*(MT**2 + 2*MW**2)*CKM31*complexconjugate(CKM31)*reglog(MU_R**2/MT**2))/(64.*(MT - MW)**2*MW**2*(MT + MW)**2*cmath.pi**2*sw**2) + (ee**2*(-2*MT**4 + 4*MT**2*MW**2 - 2*MW**4 + 4*MT**4*CKM31*complexconjugate(CKM31) - MT**2*MW**2*CKM31*complexconjugate(CKM31))*reglog(MU_R**2/MW**2))/(64.*(MT - MW)**2*(MT + MW)**2*cmath.pi**2*sw**2) - (ee**2*(-3 + 2*sw**2)**2*reglog(MU_R**2/MZ**2))/(576.*cw**2*cmath.pi**2*sw**2))'},
+                            value = {-1:'recms(CMSParam==1.0,-(ee**2*(MW**2*(18*cw**2 + (3 - 2*sw**2)**2) + 9*cw**2*MT**2*CKM31*complexconjugate(CKM31)))/(576.*cw**2*MW**2*cmath.pi**2*sw**2))',
+                                      0:'recms(CMSParam==1.0,-(ee**2*(-9*MT**2*MW**2 - 18*cw**2*MT**2*MW**2 + 9*MW**4 + 18*cw**2*MW**4 + 12*MT**2*MW**2*sw**2 - 12*MW**4*sw**2 - 4*MT**2*MW**2*sw**4 + 4*MW**4*sw**4 + 27*cw**2*MT**4*CKM31*complexconjugate(CKM31) + 27*cw**2*MT**2*MW**2*CKM31*complexconjugate(CKM31) + 9*MT**2*MW**2*reglog(16) + 18*cw**2*MT**2*MW**2*reglog(16) - 9*MW**4*reglog(16) - 18*cw**2*MW**4*reglog(16) - 12*MT**2*MW**2*sw**2*reglog(16) + 12*MW**4*sw**2*reglog(16) + 4*MT**2*MW**2*sw**4*reglog(16) - 4*MW**4*sw**4*reglog(16) + 9*cw**2*MT**4*CKM31*complexconjugate(CKM31)*reglog(16) - 9*cw**2*MT**2*MW**2*CKM31*complexconjugate(CKM31)*reglog(16) + 18*MT**2*MW**2*reglog(cmath.pi) + 36*cw**2*MT**2*MW**2*reglog(cmath.pi) - 18*MW**4*reglog(cmath.pi) - 36*cw**2*MW**4*reglog(cmath.pi) - 24*MT**2*MW**2*sw**2*reglog(cmath.pi) + 24*MW**4*sw**2*reglog(cmath.pi) + 8*MT**2*MW**2*sw**4*reglog(cmath.pi) - 8*MW**4*sw**4*reglog(cmath.pi) + 18*cw**2*MT**4*CKM31*complexconjugate(CKM31)*reglog(cmath.pi) - 18*cw**2*MT**2*MW**2*CKM31*complexconjugate(CKM31)*reglog(cmath.pi) - 18*MT**2*MW**2*reglog(4*cmath.pi) - 36*cw**2*MT**2*MW**2*reglog(4*cmath.pi) + 18*MW**4*reglog(4*cmath.pi) + 36*cw**2*MW**4*reglog(4*cmath.pi) + 24*MT**2*MW**2*sw**2*reglog(4*cmath.pi) - 24*MW**4*sw**2*reglog(4*cmath.pi) - 8*MT**2*MW**2*sw**4*reglog(4*cmath.pi) + 8*MW**4*sw**4*reglog(4*cmath.pi) - 18*cw**2*MT**4*CKM31*complexconjugate(CKM31)*reglog(4*cmath.pi) + 18*cw**2*MT**2*MW**2*CKM31*complexconjugate(CKM31)*reglog(4*cmath.pi)))/(1152.*cw**2*(MT - MW)*MW**2*(MT + MW)*cmath.pi**2*sw**2) - (ee**2*MT**4*(MT**2 + 2*MW**2)*CKM31*complexconjugate(CKM31)*reglog(MU_R**2/MT**2))/(64.*(MT - MW)**2*MW**2*(MT + MW)**2*cmath.pi**2*sw**2) + (ee**2*(-2*MT**4 + 4*MT**2*MW**2 - 2*MW**4 + 4*MT**4*CKM31*complexconjugate(CKM31) - MT**2*MW**2*CKM31*complexconjugate(CKM31))*reglog(MU_R**2/MW**2))/(64.*(MT - MW)**2*(MT + MW)**2*cmath.pi**2*sw**2) - (ee**2*(-3 + 2*sw**2)**2*reglog(MU_R**2/MZ**2))/(576.*cw**2*cmath.pi**2*sw**2))'},
                             texname = '\delta ZL_d^{EW}')
 
 
 tauWcft_UV_EW_L = CTParameter(name = 'tauWcft_UV_EW_L',
                               type = 'complex',
-                              value = {-1:'re(-(ee**2*(2*cw**2 + (1 - 2*sw**2)**2))/(64.*cw**2*cmath.pi**2*sw**2))',
-                                        0:'re(-(ee**2*(-1 - 2*cw**2 + 4*sw**2 - 4*sw**4 + 4*cw**2*reglog(MU_R**2/MW**2) + 2*(1 - 2*sw**2)**2*reglog(MU_R**2/MZ**2)))/(128.*cw**2*cmath.pi**2*sw**2))'},
+                              value = {-1:'recms(CMSParam==1.0,-(ee**2*(2*cw**2 + (1 - 2*sw**2)**2))/(64.*cw**2*cmath.pi**2*sw**2))',
+                                        0:'recms(CMSParam==1.0,-(ee**2*(-1 - 2*cw**2 + 4*sw**2 - 4*sw**4 + 4*cw**2*reglog(MU_R**2/MW**2) + 2*(1 - 2*sw**2)**2*reglog(MU_R**2/MZ**2)))/(128.*cw**2*cmath.pi**2*sw**2))'},
                               texname = '\delta ZL_tau^{EW}')
 
 
 muWcft_UV_EW_L = CTParameter(name = 'muWcft_UV_EW_L',
                              type = 'complex',
-                             value = {-1:'re(-(ee**2*(2*cw**2 + (1 - 2*sw**2)**2))/(64.*cw**2*cmath.pi**2*sw**2))',
-                                       0:'re(-(ee**2*(-1 - 2*cw**2 + 4*sw**2 - 4*sw**4 + 4*cw**2*reglog(MU_R**2/MW**2) + 2*(1 - 2*sw**2)**2*reglog(MU_R**2/MZ**2)))/(128.*cw**2*cmath.pi**2*sw**2))'},
+                             value = {-1:'recms(CMSParam==1.0,-(ee**2*(2*cw**2 + (1 - 2*sw**2)**2))/(64.*cw**2*cmath.pi**2*sw**2))',
+                                       0:'recms(CMSParam==1.0,-(ee**2*(-1 - 2*cw**2 + 4*sw**2 - 4*sw**4 + 4*cw**2*reglog(MU_R**2/MW**2) + 2*(1 - 2*sw**2)**2*reglog(MU_R**2/MZ**2)))/(128.*cw**2*cmath.pi**2*sw**2))'},
                              texname = '\delta ZL_mu^{EW}')
 
 
 eWcft_UV_EW_L = CTParameter(name = 'eWcft_UV_EW_L',
                             type = 'complex',
-                            value = {-1:'re(-(ee**2*(2*cw**2 + (1 - 2*sw**2)**2))/(64.*cw**2*cmath.pi**2*sw**2))',
-                                      0:'re(-(ee**2*(-1 - 2*cw**2 + 4*sw**2 - 4*sw**4 + 4*cw**2*reglog(MU_R**2/MW**2) + 2*(1 - 2*sw**2)**2*reglog(MU_R**2/MZ**2)))/(128.*cw**2*cmath.pi**2*sw**2))'},
+                            value = {-1:'recms(CMSParam==1.0,-(ee**2*(2*cw**2 + (1 - 2*sw**2)**2))/(64.*cw**2*cmath.pi**2*sw**2))',
+                                      0:'recms(CMSParam==1.0,-(ee**2*(-1 - 2*cw**2 + 4*sw**2 - 4*sw**4 + 4*cw**2*reglog(MU_R**2/MW**2) + 2*(1 - 2*sw**2)**2*reglog(MU_R**2/MZ**2)))/(128.*cw**2*cmath.pi**2*sw**2))'},
                             texname = '\delta ZL_e^{EW}')
 
 
 vtWcft_UV_EW_L = CTParameter(name = 'vtWcft_UV_EW_L',
                              type = 'complex',
-                             value = {-1:'re(-((1 + 2*cw**2)*ee**2)/(64.*cw**2*cmath.pi**2*sw**2))',
-                                       0:'re(-(ee**2*(-1 - 2*cw**2 + 4*cw**2*reglog(MU_R**2/MW**2) + 2*reglog(MU_R**2/MZ**2)))/(128.*cw**2*cmath.pi**2*sw**2))'},
+                             value = {-1:'recms(CMSParam==1.0,-((1 + 2*cw**2)*ee**2)/(64.*cw**2*cmath.pi**2*sw**2))',
+                                       0:'recms(CMSParam==1.0,-(ee**2*(-1 - 2*cw**2 + 4*cw**2*reglog(MU_R**2/MW**2) + 2*reglog(MU_R**2/MZ**2)))/(128.*cw**2*cmath.pi**2*sw**2))'},
                              texname = '\delta ZL_vt^{EW}')
 
 
 vmWcft_UV_EW_L = CTParameter(name = 'vmWcft_UV_EW_L',
                              type = 'complex',
-                             value = {-1:'re(-((1 + 2*cw**2)*ee**2)/(64.*cw**2*cmath.pi**2*sw**2))',
-                                       0:'re(-(ee**2*(-1 - 2*cw**2 + 4*cw**2*reglog(MU_R**2/MW**2) + 2*reglog(MU_R**2/MZ**2)))/(128.*cw**2*cmath.pi**2*sw**2))'},
+                             value = {-1:'recms(CMSParam==1.0,-((1 + 2*cw**2)*ee**2)/(64.*cw**2*cmath.pi**2*sw**2))',
+                                       0:'recms(CMSParam==1.0,-(ee**2*(-1 - 2*cw**2 + 4*cw**2*reglog(MU_R**2/MW**2) + 2*reglog(MU_R**2/MZ**2)))/(128.*cw**2*cmath.pi**2*sw**2))'},
                              texname = '\delta ZL_vm^{EW}')
 
 
 veWcft_UV_EW_L = CTParameter(name = 'veWcft_UV_EW_L',
                              type = 'complex',
-                             value = {-1:'re(-((1 + 2*cw**2)*ee**2)/(64.*cw**2*cmath.pi**2*sw**2))',
-                                       0:'re(-(ee**2*(-1 - 2*cw**2 + 4*cw**2*reglog(MU_R**2/MW**2) + 2*reglog(MU_R**2/MZ**2)))/(128.*cw**2*cmath.pi**2*sw**2))'},
+                             value = {-1:'recms(CMSParam==1.0,-((1 + 2*cw**2)*ee**2)/(64.*cw**2*cmath.pi**2*sw**2))',
+                                       0:'recms(CMSParam==1.0,-(ee**2*(-1 - 2*cw**2 + 4*cw**2*reglog(MU_R**2/MW**2) + 2*reglog(MU_R**2/MZ**2)))/(128.*cw**2*cmath.pi**2*sw**2))'},
                              texname = '\delta ZL_ve^{EW}')
 
 HWcft_UV_EW = CTParameter(name = 'HWcft_UV_EW',
                           type = 'complex',
-                          value = {-1:'re((ee**2*((1 + 2*cw**2)*MW**2 - cw**2*MT**2*Ncol))/(32.*cw**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_HWcft_UV_EW.value[-1],
-                          0:'re(-(ee**2*((1 + 2*cw**2)*MW**2 - cw**2*MT**2*Ncol)*reglog(4*cmath.pi))/(32.*cw**2*MW**2*cmath.pi**2*sw**2) + (ee**2*((4*(4*MW**4 + cw**4*(3*MH**4 + 6*MW**4 - 4*MT**4*Ncol + MH**2*(MW**2*(2 + reglog(16) + 2*reglog(cmath.pi)) + MT**2*Ncol*(-1 - reglog(4*cmath.pi)))) + cw**2*MW**2*(-MZ**2 + MH**2*(1 + reglog(4*cmath.pi)))))/(cw**4*MH**2*MW**2) - (6*MH**2*reglog(MU_R**2/MH**2))/MW**2 + (8*MT**4*Ncol*reglog(MU_R**2/MT**2))/(MH**2*MW**2) + (4*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(MU_R**2/MW**2))/(MH**4 - 4*MH**2*MW**2) + (2*MZ**2*(cw**4*MH**4 + 16*MW**4 - 4*cw**2*MW**2*(MH**2 + MZ**2))*reglog(MU_R**2/MZ**2))/(cw**4*MH**2*MW**2*(MH**2 - 4*MZ**2)) - (2*(16*MW**4*(-MH**2 + 4*MW**2)*MZ**2 + 2*cw**2*MW**2*(MH**2 - 4*MW**2)*(MH**4 - 2*MH**2*MZ**2 + 2*MZ**4) + cw**4*(3*MH**8 - MH**6*(10*MW**2 + 13*MZ**2 + 2*MT**2*Ncol) + 32*MW**2*MZ**2*(3*MW**4 - 2*MT**4*Ncol) - 8*MH**2*(3*MW**6 - 4*MW**4*MZ**2 - 2*MT**4*MZ**2*Ncol - 2*MT**2*MW**2*(MT**2 - 2*MZ**2)*Ncol) + MH**4*(-8*MW**4 - 4*MT**2*(MT**2 - 2*MZ**2)*Ncol + MW**2*(44*MZ**2 + 8*MT**2*Ncol))))*reglog((MH**2 + vep*complex(0,-1))/MU_R**2))/(cw**4*MH**2*(MH - 2*MW)*MW**2*(MH + 2*MW)*(MH - 2*MZ)*(MH + 2*MZ)) + (4*MT**2*(MH**2 + 2*MT**2)*Ncol*reglog((-MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(2.*MH**2)))/(MH**2*MW**2) + (4*MT**2*(MH**2 + 2*MT**2)*Ncol*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(2.*MH**2)))/(MH**2*MW**2) - (2*MT**2*(MH**2 + 2*MT**2)*Ncol*(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))))/(MH**4*MW**2) - (2*MT**2*(MH**2 + 2*MT**2)*Ncol*(MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))))/(MH**4*MW**2) - (4*(MH**2 - 6*MW**2)*(MH**2 + 2*MW**2)*reglog((-MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(2.*MH**2)))/(MH**4 - 4*MH**2*MW**2) - (4*(MH**2 - 6*MW**2)*(MH**2 + 2*MW**2)*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(2.*MH**2)))/(MH**4 - 4*MH**2*MW**2) + (2*(MH**2 - 6*MW**2)*(MH**2 + 2*MW**2)*(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))))/(MH**6 - 4*MH**4*MW**2) + (2*(MH**2 - 6*MW**2)*(MH**2 + 2*MW**2)*(MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))))/(MH**6 - 4*MH**4*MW**2) + (2*(cw**4*MH**4*MZ**2 + 16*MW**4*MZ**2 - 2*cw**2*MW**2*(MH**4 - 2*MH**2*MZ**2 + 2*MZ**4))*reglog((-MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(2.*MH**2)))/(cw**4*MH**2*MW**2*(MH**2 - 4*MZ**2)) + (2*(cw**4*MH**4*MZ**2 + 16*MW**4*MZ**2 - 2*cw**2*MW**2*(MH**4 - 2*MH**2*MZ**2 + 2*MZ**4))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(2.*MH**2)))/(cw**4*MH**2*MW**2*(MH**2 - 4*MZ**2)) - ((cw**4*MH**4*MZ**2 + 16*MW**4*MZ**2 - 2*cw**2*MW**2*(MH**4 - 2*MH**2*MZ**2 + 2*MZ**4))*(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))))/(cw**4*MH**4*MW**2*(MH**2 - 4*MZ**2)) + ((cw**4*MH**4*MZ**2 + 16*MW**4*MZ**2 - 2*cw**2*MW**2*(MH**4 - 2*MH**2*MZ**2 + 2*MZ**4))*(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))))/(cw**4*MH**4*MW**2*(MH**2 - 4*MZ**2)) + (3*(MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))*reglog((-MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))))/MW**2 - (3*(-MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))*reglog((MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))))/MW**2 - (6*MH**2*reglog(-0.5 - cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4))/(2.*MH**2)))/MW**2 - (6*MH**2*reglog(-0.5 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4))/(2.*MH**2)))/MW**2))/(128.*cmath.pi**2*sw**2))'+'+'+dMB_HWcft_UV_EW.value[0]},
+                          value = {-1:'recms(CMSParam==1.0 and WH != 0,(ee**2*((1 + 2*cw**2)*MW**2 - cw**2*MT**2*Ncol))/(32.*cw**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_HWcft_UV_EW.value[-1],
+                          0:'recms(CMSParam==1.0 and WH != 0,-(ee**2*((1 + 2*cw**2)*MW**2 - cw**2*MT**2*Ncol)*reglog(4*cmath.pi))/(32.*cw**2*MW**2*cmath.pi**2*sw**2) + (ee**2*((4*(4*MW**4 + cw**4*(3*MH**4 + 6*MW**4 - 4*MT**4*Ncol + MH**2*(MW**2*(2 + reglog(16) + 2*reglog(cmath.pi)) + MT**2*Ncol*(-1 - reglog(4*cmath.pi)))) + cw**2*MW**2*(-MZ**2 + MH**2*(1 + reglog(4*cmath.pi)))))/(cw**4*MH**2*MW**2) - (6*MH**2*reglog(MU_R**2/MH**2))/MW**2 + (8*MT**4*Ncol*reglog(MU_R**2/MT**2))/(MH**2*MW**2) + (4*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(MU_R**2/MW**2))/(MH**4 - 4*MH**2*MW**2) + (2*MZ**2*(cw**4*MH**4 + 16*MW**4 - 4*cw**2*MW**2*(MH**2 + MZ**2))*reglog(MU_R**2/MZ**2))/(cw**4*MH**2*MW**2*(MH**2 - 4*MZ**2)) - (2*(16*MW**4*(-MH**2 + 4*MW**2)*MZ**2 + 2*cw**2*MW**2*(MH**2 - 4*MW**2)*(MH**4 - 2*MH**2*MZ**2 + 2*MZ**4) + cw**4*(3*MH**8 - MH**6*(10*MW**2 + 13*MZ**2 + 2*MT**2*Ncol) + 32*MW**2*MZ**2*(3*MW**4 - 2*MT**4*Ncol) - 8*MH**2*(3*MW**6 - 4*MW**4*MZ**2 - 2*MT**4*MZ**2*Ncol - 2*MT**2*MW**2*(MT**2 - 2*MZ**2)*Ncol) + MH**4*(-8*MW**4 - 4*MT**2*(MT**2 - 2*MZ**2)*Ncol + MW**2*(44*MZ**2 + 8*MT**2*Ncol))))*reglog((MH**2 + vep*complex(0,-1))/MU_R**2))/(cw**4*MH**2*(MH - 2*MW)*MW**2*(MH + 2*MW)*(MH - 2*MZ)*(MH + 2*MZ)) + (4*MT**2*(MH**2 + 2*MT**2)*Ncol*reglog((-MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(2.*MH**2)))/(MH**2*MW**2) + (4*MT**2*(MH**2 + 2*MT**2)*Ncol*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(2.*MH**2)))/(MH**2*MW**2) - (2*MT**2*(MH**2 + 2*MT**2)*Ncol*(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))))/(MH**4*MW**2) - (2*MT**2*(MH**2 + 2*MT**2)*Ncol*(MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MT**2 + vep*complex(0,4))))))/(MH**4*MW**2) - (4*(MH**2 - 6*MW**2)*(MH**2 + 2*MW**2)*reglog((-MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(2.*MH**2)))/(MH**4 - 4*MH**2*MW**2) - (4*(MH**2 - 6*MW**2)*(MH**2 + 2*MW**2)*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(2.*MH**2)))/(MH**4 - 4*MH**2*MW**2) + (2*(MH**2 - 6*MW**2)*(MH**2 + 2*MW**2)*(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))))/(MH**6 - 4*MH**4*MW**2) + (2*(MH**2 - 6*MW**2)*(MH**2 + 2*MW**2)*(MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MW**2 + vep*complex(0,4))))))/(MH**6 - 4*MH**4*MW**2) + (2*(cw**4*MH**4*MZ**2 + 16*MW**4*MZ**2 - 2*cw**2*MW**2*(MH**4 - 2*MH**2*MZ**2 + 2*MZ**4))*reglog((-MH**2 - cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(2.*MH**2)))/(cw**4*MH**2*MW**2*(MH**2 - 4*MZ**2)) + (2*(cw**4*MH**4*MZ**2 + 16*MW**4*MZ**2 - 2*cw**2*MW**2*(MH**4 - 2*MH**2*MZ**2 + 2*MZ**4))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(2.*MH**2)))/(cw**4*MH**2*MW**2*(MH**2 - 4*MZ**2)) - ((cw**4*MH**4*MZ**2 + 16*MW**4*MZ**2 - 2*cw**2*MW**2*(MH**4 - 2*MH**2*MZ**2 + 2*MZ**4))*(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))*reglog((-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))))/(cw**4*MH**4*MW**2*(MH**2 - 4*MZ**2)) + ((cw**4*MH**4*MZ**2 + 16*MW**4*MZ**2 - 2*cw**2*MW**2*(MH**4 - 2*MH**2*MZ**2 + 2*MZ**4))*(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))*reglog((MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))/(-MH**2 + cmath.sqrt(MH**2*(MH**2 - 4*MZ**2 + vep*complex(0,4))))))/(cw**4*MH**4*MW**2*(MH**2 - 4*MZ**2)) + (3*(MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))*reglog((-MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))))/MW**2 - (3*(-MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))*reglog((MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4)))))/MW**2 - (6*MH**2*reglog(-0.5 - cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4))/(2.*MH**2)))/MW**2 - (6*MH**2*reglog(-0.5 + cmath.sqrt(-3*MH**4 + MH**2*vep*complex(0,4))/(2.*MH**2)))/MW**2))/(128.*cmath.pi**2*sw**2))'+'+'+dMB_HWcft_UV_EW.value[0]},
                           texname = '\delta Z_{H}^{EW}')
 
 G0Wcft_UV_EW = CTParameter(name = 'G0Wcft_UV_EW',
                            type = 'complex',
-                           value = {-1:'re((ee**2*((1 + 2*cw**2)*MW**2 - cw**2*MT**2*Ncol))/(32.*cw**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_G0Wcft_UV_EW.value[-1],
-                           0:'re(-(ee**2*((1 + 2*cw**2)*MW**2 - cw**2*MT**2*Ncol)*reglog(4*cmath.pi))/(32.*cw**2*MW**2*cmath.pi**2*sw**2) + (ee**2*((2*(MW**2*(-2*MH**2 + MZ**2*(3 + reglog(16) + 2*reglog(cmath.pi))) + cw**2*(MH**4 + MZ**2*(MT**2*Ncol*(-2 - reglog(16) - 2*reglog(cmath.pi)) + MW**2*(4 + reglog(256) + 4*reglog(cmath.pi))))))/(cw**2*MW**2*MZ**2) - (2*(MH**2 - 2*MZ**2)*(cw**2*MH**4 - MW**2*(2*MH**2 + MZ**2))*reglog(MU_R**2/MH**2))/(cw**2*MW**2*MZ**2*(MH**2 - 4*MZ**2)) - (8*MT**4*Ncol*reglog(MU_R**2/MT**2))/(MW**2*(4*MT**2 - MZ**2)) + (16*MW**2*reglog(MU_R**2/MW**2))/(4*MW**2 - MZ**2) + (2*(cw**2*MH**4 - MW**2*(2*MH**2 + MZ**2))*reglog(MU_R**2/MZ**2))/(cw**2*MW**2*(MH**2 - 4*MZ**2)) - (2*(MW**2*(4*MT**2 - MZ**2)*(-4*MW**2 + MZ**2)*(2*MH**4 - 7*MH**2*MZ**2 + 5*MZ**4) + cw**2*(-(MH**6*(4*MT**2 - MZ**2)*(-4*MW**2 + MZ**2)) - 3*MH**4*MZ**2*(-4*MT**2 + MZ**2)*(-4*MW**2 + MZ**2) - 2*MH**2*MZ**2*(4*MW**4*MZ**2 - 2*MW**2*MZ**4 + MT**4*(8*MW**2*Ncol - 2*MZ**2*Ncol) + MT**2*(-16*MW**4 - 4*MW**2*MZ**2*(-2 + Ncol) + MZ**4*Ncol)) + 8*MZ**4*(4*MW**4*MZ**2 - 2*MW**2*MZ**4 + MT**4*(8*MW**2*Ncol - 2*MZ**2*Ncol) + MT**2*(-16*MW**4 - 4*MW**2*MZ**2*(-2 + Ncol) + MZ**4*Ncol))))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/(cw**2*MW**2*(2*MW - MZ)*MZ**2*(-2*MT + MZ)*(2*MT + MZ)*(2*MW + MZ)*(-MH + 2*MZ)*(MH + 2*MZ)) + (2*(cw**2*(MH**6 - 3*MH**4*MZ**2) + MW**2*(-2*MH**4 + 7*MH**2*MZ**2 - 5*MZ**4))*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/(cw**2*MW**2*MZ**2*(-MH**2 + 4*MZ**2)) + (2*(cw**2*(MH**6 - 3*MH**4*MZ**2) + MW**2*(-2*MH**4 + 7*MH**2*MZ**2 - 5*MZ**4))*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/(cw**2*MW**2*MZ**2*(-MH**2 + 4*MZ**2)) + (4*MT**2*(2*MT**2 - MZ**2)*Ncol*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(MW**2*(4*MT**2 - MZ**2)) + (4*MT**2*(2*MT**2 - MZ**2)*Ncol*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(MW**2*(4*MT**2 - MZ**2)) + (2*MT**2*(2*MT**2 - MZ**2)*Ncol*(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/(MW**2*MZ**2*(-4*MT**2 + MZ**2)) + (2*MT**2*(2*MT**2 - MZ**2)*Ncol*(MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/(MW**2*MZ**2*(-4*MT**2 + MZ**2)) - (8*(2*MW**2 - MZ**2)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MW**2 - MZ**2) - (8*(2*MW**2 - MZ**2)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MW**2 - MZ**2) + (4*(-2*MW**2 + MZ**2)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/(-4*MW**2*MZ**2 + MZ**4) + (4*(-2*MW**2 + MZ**2)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/(-4*MW**2*MZ**2 + MZ**4) + ((cw**2*(MH**6 - 3*MH**4*MZ**2) + MW**2*(-2*MH**4 + 7*MH**2*MZ**2 - 5*MZ**4))*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((MH**2 - 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/(cw**2*MW**2*MZ**4*(MH**2 - 4*MZ**2)) - ((cw**2*(MH**6 - 3*MH**4*MZ**2) + MW**2*(-2*MH**4 + 7*MH**2*MZ**2 - 5*MZ**4))*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/(cw**2*MW**2*MZ**4*(MH**2 - 4*MZ**2))))/(128.*cmath.pi**2*sw**2))'+'+'+dMB_G0Wcft_UV_EW.value[0]},
+                           value = {-1:'recms(CMSParam==1.0 and WZ != 0,(ee**2*((1 + 2*cw**2)*MW**2 - cw**2*MT**2*Ncol))/(32.*cw**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_G0Wcft_UV_EW.value[-1],
+                           0:'recms(CMSParam==1.0 and WZ != 0,-(ee**2*((1 + 2*cw**2)*MW**2 - cw**2*MT**2*Ncol)*reglog(4*cmath.pi))/(32.*cw**2*MW**2*cmath.pi**2*sw**2) + (ee**2*((2*(MW**2*(-2*MH**2 + MZ**2*(3 + reglog(16) + 2*reglog(cmath.pi))) + cw**2*(MH**4 + MZ**2*(MT**2*Ncol*(-2 - reglog(16) - 2*reglog(cmath.pi)) + MW**2*(4 + reglog(256) + 4*reglog(cmath.pi))))))/(cw**2*MW**2*MZ**2) - (2*(MH**2 - 2*MZ**2)*(cw**2*MH**4 - MW**2*(2*MH**2 + MZ**2))*reglog(MU_R**2/MH**2))/(cw**2*MW**2*MZ**2*(MH**2 - 4*MZ**2)) - (8*MT**4*Ncol*reglog(MU_R**2/MT**2))/(MW**2*(4*MT**2 - MZ**2)) + (16*MW**2*reglog(MU_R**2/MW**2))/(4*MW**2 - MZ**2) + (2*(cw**2*MH**4 - MW**2*(2*MH**2 + MZ**2))*reglog(MU_R**2/MZ**2))/(cw**2*MW**2*(MH**2 - 4*MZ**2)) - (2*(MW**2*(4*MT**2 - MZ**2)*(-4*MW**2 + MZ**2)*(2*MH**4 - 7*MH**2*MZ**2 + 5*MZ**4) + cw**2*(-(MH**6*(4*MT**2 - MZ**2)*(-4*MW**2 + MZ**2)) - 3*MH**4*MZ**2*(-4*MT**2 + MZ**2)*(-4*MW**2 + MZ**2) - 2*MH**2*MZ**2*(4*MW**4*MZ**2 - 2*MW**2*MZ**4 + MT**4*(8*MW**2*Ncol - 2*MZ**2*Ncol) + MT**2*(-16*MW**4 - 4*MW**2*MZ**2*(-2 + Ncol) + MZ**4*Ncol)) + 8*MZ**4*(4*MW**4*MZ**2 - 2*MW**2*MZ**4 + MT**4*(8*MW**2*Ncol - 2*MZ**2*Ncol) + MT**2*(-16*MW**4 - 4*MW**2*MZ**2*(-2 + Ncol) + MZ**4*Ncol))))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/(cw**2*MW**2*(2*MW - MZ)*MZ**2*(-2*MT + MZ)*(2*MT + MZ)*(2*MW + MZ)*(-MH + 2*MZ)*(MH + 2*MZ)) + (2*(cw**2*(MH**6 - 3*MH**4*MZ**2) + MW**2*(-2*MH**4 + 7*MH**2*MZ**2 - 5*MZ**4))*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/(cw**2*MW**2*MZ**2*(-MH**2 + 4*MZ**2)) + (2*(cw**2*(MH**6 - 3*MH**4*MZ**2) + MW**2*(-2*MH**4 + 7*MH**2*MZ**2 - 5*MZ**4))*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/(cw**2*MW**2*MZ**2*(-MH**2 + 4*MZ**2)) + (4*MT**2*(2*MT**2 - MZ**2)*Ncol*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(MW**2*(4*MT**2 - MZ**2)) + (4*MT**2*(2*MT**2 - MZ**2)*Ncol*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(MW**2*(4*MT**2 - MZ**2)) + (2*MT**2*(2*MT**2 - MZ**2)*Ncol*(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/(MW**2*MZ**2*(-4*MT**2 + MZ**2)) + (2*MT**2*(2*MT**2 - MZ**2)*Ncol*(MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/(MW**2*MZ**2*(-4*MT**2 + MZ**2)) - (8*(2*MW**2 - MZ**2)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MW**2 - MZ**2) - (8*(2*MW**2 - MZ**2)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MW**2 - MZ**2) + (4*(-2*MW**2 + MZ**2)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/(-4*MW**2*MZ**2 + MZ**4) + (4*(-2*MW**2 + MZ**2)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/(-4*MW**2*MZ**2 + MZ**4) + ((cw**2*(MH**6 - 3*MH**4*MZ**2) + MW**2*(-2*MH**4 + 7*MH**2*MZ**2 - 5*MZ**4))*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((MH**2 - 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/(cw**2*MW**2*MZ**4*(MH**2 - 4*MZ**2)) - ((cw**2*(MH**6 - 3*MH**4*MZ**2) + MW**2*(-2*MH**4 + 7*MH**2*MZ**2 - 5*MZ**4))*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/(cw**2*MW**2*MZ**4*(MH**2 - 4*MZ**2))))/(128.*cmath.pi**2*sw**2))'+'+'+dMB_G0Wcft_UV_EW.value[0]},
                            texname = '\delta Z_{G0}^{EW}')
 
 GpWcft_UV_EW = CTParameter(name = 'GpWcft_UV_EW',
                            type = 'complex',
-                           value = {-1:'re((ee**2*(cw**4*MW**2 + MW**2*sw**4 + cw**2*(-(MT**2*Ncol) + 2*MW**2*(1 + sw**2))))/(32.*cw**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_GpWcft_UV_EW.value[-1],
-                           0:'re(-(ee**2*(cw**4*MW**2 + MW**2*sw**4 + cw**2*(-(MT**2*Ncol) + 2*MW**2*(1 + sw**2)))*reglog(4*cmath.pi))/(32.*cw**2*MW**2*cmath.pi**2*sw**2) + (ee**2*((2*MW**2*(2*cw**3*MW**3*MZ - 2*cw*MW**3*MZ*sw**2 + cw**4*MW**2*(MZ**2 + MW**2*(reglog(16) + 2*reglog(cmath.pi))) + MW**2*sw**4*(MZ**2 + MW**2*(16 + reglog(16) + 2*reglog(cmath.pi))) + cw**2*(MH**4 - 2*MH**2*MW**2 - 2*MT**4*Ncol - MW**2*(2*MZ**2*(1 + sw**2) + MT**2*Ncol*(2 + reglog(16) + 2*reglog(cmath.pi))) + MW**4*(6 + reglog(256) + 4*reglog(cmath.pi) + sw**2*(12 + reglog(256) + 4*reglog(cmath.pi))))))/cw**2 - (2*MW**2*(MH**2 - 2*MW**2)*(MH**4 - 2*MH**2*MW**2 - MW**4)*reglog(MU_R**2/MH**2))/(MH**2 - 4*MW**2) - 4*MT**2*MW**4*Ncol*reglog(MU_R**2/MT**2) - (2*MW**4*(2*cw**3*MW**3*(MH**2 - 4*MW**2)*MZ + cw**4*MW**2*(-MH**2 + 4*MW**2)*(4*MW**2 - MZ**2) + 2*cw*MW**3*(-MH**2 + 4*MW**2)*MZ*sw**2 + MW**2*(MH**2 - 4*MW**2)*(12*MW**2 + MZ**2)*sw**4 + cw**2*(MH**4*(-4*MW**2 + MZ**2) + MH**2*MW**2*(MW**2*(7 - 24*sw**2) + 2*MZ**2*(-2 + 3*sw**2)) + MW**4*(MZ**2*(7 - 24*sw**2) + MW**2*(8 + 96*sw**2))))*reglog(MU_R**2/MW**2))/(cw**2*(MH - 2*MW)*(MH + 2*MW)*(2*MW - MZ)*(2*MW + MZ)) + (2*MW**4*(2*MW**2 - MZ**2)*(-2*cw**3*MW*MZ + cw**4*(4*MW**2 - MZ**2) + 2*cw*MW*MZ*sw**2 - (12*MW**2 + MZ**2)*sw**4 + cw**2*(MW**2*(1 - 8*sw**2) + 2*MZ**2*(1 + sw**2)))*reglog(MU_R**2/MZ**2))/(cw**2*(4*MW**2 - MZ**2)) - 4*MT**2*(MT - MW)*(MT + MW)*(MT**2 + MW**2)*Ncol*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2) + (2*MW**2*(-2*cw**3*MW**3*(MH**2 - 4*MW**2)*(3*MW**2*MZ - MZ**3) + cw**4*MW**2*(MH**2 - 4*MW**2)*(4*MW**4 - 5*MW**2*MZ**2 + MZ**4) + 2*cw*MW**3*(MH**2 - 4*MW**2)*MZ*(3*MW**2 - MZ**2)*sw**2 + MW**2*(-MH**2 + 4*MW**2)*(44*MW**4 - 11*MW**2*MZ**2 - MZ**4)*sw**4 + cw**2*(MH**6*(-4*MW**2 + MZ**2) + 5*MH**4*(4*MW**4 - MW**2*MZ**2) - MH**2*MW**2*(2*MZ**4*(1 + sw**2) - 2*MW**2*MZ**2*(7 + 5*sw**2) + MW**4*(33 + 8*sw**2)) + MW**4*(8*MZ**4*(1 + sw**2) + 8*MW**4*(5 + 4*sw**2) - MW**2*MZ**2*(33 + 40*sw**2))))*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/(cw**2*(MH - 2*MW)*(MH + 2*MW)*(2*MW - MZ)*(2*MW + MZ)) + (2*MW**4*(cw**3*(-6*MW**3*MZ + 2*MW*MZ**3) + cw**4*(4*MW**4 - 5*MW**2*MZ**2 + MZ**4) + 2*cw*MW*MZ*(3*MW**2 - MZ**2)*sw**2 + (-44*MW**4 + 11*MW**2*MZ**2 + MZ**4)*sw**4 - cw**2*(MW**2 - MZ**2)*(-2*MZ**2*(1 + sw**2) + MW**2*(5 + 8*sw**2)))*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*(4*MW**2 - MZ**2)) + (2*MW**4*(cw**3*(-6*MW**3*MZ + 2*MW*MZ**3) + cw**4*(4*MW**4 - 5*MW**2*MZ**2 + MZ**4) + 2*cw*MW*MZ*(3*MW**2 - MZ**2)*sw**2 + (-44*MW**4 + 11*MW**2*MZ**2 + MZ**4)*sw**4 - cw**2*(MW**2 - MZ**2)*(-2*MZ**2*(1 + sw**2) + MW**2*(5 + 8*sw**2)))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*(4*MW**2 - MZ**2)) - (MW**2*(cw**3*(-6*MW**3*MZ + 2*MW*MZ**3) + cw**4*(4*MW**4 - 5*MW**2*MZ**2 + MZ**4) + 2*cw*MW*MZ*(3*MW**2 - MZ**2)*sw**2 + (-44*MW**4 + 11*MW**2*MZ**2 + MZ**4)*sw**4 - cw**2*(MW**2 - MZ**2)*(-2*MZ**2*(1 + sw**2) + MW**2*(5 + 8*sw**2)))*(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*(4*MW**2 - MZ**2)) - (MW**2*(cw**3*(-6*MW**3*MZ + 2*MW*MZ**3) + cw**4*(4*MW**4 - 5*MW**2*MZ**2 + MZ**4) + 2*cw*MW*MZ*(3*MW**2 - MZ**2)*sw**2 + (-44*MW**4 + 11*MW**2*MZ**2 + MZ**4)*sw**4 - cw**2*(MW**2 - MZ**2)*(-2*MZ**2*(1 + sw**2) + MW**2*(5 + 8*sw**2)))*(2*MW**2 - MZ**2 - cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*(4*MW**2 - MZ**2)) - (2*MW**2*(-MH**6 + 5*MH**4*MW**2 - 7*MH**2*MW**4 + 5*MW**6)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/(-MH**2 + 4*MW**2) - (2*MW**2*(-MH**6 + 5*MH**4*MW**2 - 7*MH**2*MW**4 + 5*MW**6)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/(-MH**2 + 4*MW**2) + ((MH**6 - 5*MH**4*MW**2 + 7*MH**2*MW**4 - 5*MW**6)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((MH**2 - 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/(MH**2 - 4*MW**2) - ((MH**6 - 5*MH**4*MW**2 + 7*MH**2*MW**4 - 5*MW**6)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/(MH**2 - 4*MW**2)))/(128.*MW**6*cmath.pi**2*sw**2))'+'+'+dMB_GpWcft_UV_EW.value[0]},
+                           value = {-1:'recms(CMSParam==1.0 and WW != 0,(ee**2*(cw**4*MW**2 + MW**2*sw**4 + cw**2*(-(MT**2*Ncol) + 2*MW**2*(1 + sw**2))))/(32.*cw**2*MW**2*cmath.pi**2*sw**2))'+'+'+dMB_GpWcft_UV_EW.value[-1],
+                           0:'recms(CMSParam==1.0 and WW != 0,-(ee**2*(cw**4*MW**2 + MW**2*sw**4 + cw**2*(-(MT**2*Ncol) + 2*MW**2*(1 + sw**2)))*reglog(4*cmath.pi))/(32.*cw**2*MW**2*cmath.pi**2*sw**2) + (ee**2*((2*MW**2*(2*cw**3*MW**3*MZ - 2*cw*MW**3*MZ*sw**2 + cw**4*MW**2*(MZ**2 + MW**2*(reglog(16) + 2*reglog(cmath.pi))) + MW**2*sw**4*(MZ**2 + MW**2*(16 + reglog(16) + 2*reglog(cmath.pi))) + cw**2*(MH**4 - 2*MH**2*MW**2 - 2*MT**4*Ncol - MW**2*(2*MZ**2*(1 + sw**2) + MT**2*Ncol*(2 + reglog(16) + 2*reglog(cmath.pi))) + MW**4*(6 + reglog(256) + 4*reglog(cmath.pi) + sw**2*(12 + reglog(256) + 4*reglog(cmath.pi))))))/cw**2 - (2*MW**2*(MH**2 - 2*MW**2)*(MH**4 - 2*MH**2*MW**2 - MW**4)*reglog(MU_R**2/MH**2))/(MH**2 - 4*MW**2) - 4*MT**2*MW**4*Ncol*reglog(MU_R**2/MT**2) - (2*MW**4*(2*cw**3*MW**3*(MH**2 - 4*MW**2)*MZ + cw**4*MW**2*(-MH**2 + 4*MW**2)*(4*MW**2 - MZ**2) + 2*cw*MW**3*(-MH**2 + 4*MW**2)*MZ*sw**2 + MW**2*(MH**2 - 4*MW**2)*(12*MW**2 + MZ**2)*sw**4 + cw**2*(MH**4*(-4*MW**2 + MZ**2) + MH**2*MW**2*(MW**2*(7 - 24*sw**2) + 2*MZ**2*(-2 + 3*sw**2)) + MW**4*(MZ**2*(7 - 24*sw**2) + MW**2*(8 + 96*sw**2))))*reglog(MU_R**2/MW**2))/(cw**2*(MH - 2*MW)*(MH + 2*MW)*(2*MW - MZ)*(2*MW + MZ)) + (2*MW**4*(2*MW**2 - MZ**2)*(-2*cw**3*MW*MZ + cw**4*(4*MW**2 - MZ**2) + 2*cw*MW*MZ*sw**2 - (12*MW**2 + MZ**2)*sw**4 + cw**2*(MW**2*(1 - 8*sw**2) + 2*MZ**2*(1 + sw**2)))*reglog(MU_R**2/MZ**2))/(cw**2*(4*MW**2 - MZ**2)) - 4*MT**2*(MT - MW)*(MT + MW)*(MT**2 + MW**2)*Ncol*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2) + (2*MW**2*(-2*cw**3*MW**3*(MH**2 - 4*MW**2)*(3*MW**2*MZ - MZ**3) + cw**4*MW**2*(MH**2 - 4*MW**2)*(4*MW**4 - 5*MW**2*MZ**2 + MZ**4) + 2*cw*MW**3*(MH**2 - 4*MW**2)*MZ*(3*MW**2 - MZ**2)*sw**2 + MW**2*(-MH**2 + 4*MW**2)*(44*MW**4 - 11*MW**2*MZ**2 - MZ**4)*sw**4 + cw**2*(MH**6*(-4*MW**2 + MZ**2) + 5*MH**4*(4*MW**4 - MW**2*MZ**2) - MH**2*MW**2*(2*MZ**4*(1 + sw**2) - 2*MW**2*MZ**2*(7 + 5*sw**2) + MW**4*(33 + 8*sw**2)) + MW**4*(8*MZ**4*(1 + sw**2) + 8*MW**4*(5 + 4*sw**2) - MW**2*MZ**2*(33 + 40*sw**2))))*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/(cw**2*(MH - 2*MW)*(MH + 2*MW)*(2*MW - MZ)*(2*MW + MZ)) + (2*MW**4*(cw**3*(-6*MW**3*MZ + 2*MW*MZ**3) + cw**4*(4*MW**4 - 5*MW**2*MZ**2 + MZ**4) + 2*cw*MW*MZ*(3*MW**2 - MZ**2)*sw**2 + (-44*MW**4 + 11*MW**2*MZ**2 + MZ**4)*sw**4 - cw**2*(MW**2 - MZ**2)*(-2*MZ**2*(1 + sw**2) + MW**2*(5 + 8*sw**2)))*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*(4*MW**2 - MZ**2)) + (2*MW**4*(cw**3*(-6*MW**3*MZ + 2*MW*MZ**3) + cw**4*(4*MW**4 - 5*MW**2*MZ**2 + MZ**4) + 2*cw*MW*MZ*(3*MW**2 - MZ**2)*sw**2 + (-44*MW**4 + 11*MW**2*MZ**2 + MZ**4)*sw**4 - cw**2*(MW**2 - MZ**2)*(-2*MZ**2*(1 + sw**2) + MW**2*(5 + 8*sw**2)))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*(4*MW**2 - MZ**2)) - (MW**2*(cw**3*(-6*MW**3*MZ + 2*MW*MZ**3) + cw**4*(4*MW**4 - 5*MW**2*MZ**2 + MZ**4) + 2*cw*MW*MZ*(3*MW**2 - MZ**2)*sw**2 + (-44*MW**4 + 11*MW**2*MZ**2 + MZ**4)*sw**4 - cw**2*(MW**2 - MZ**2)*(-2*MZ**2*(1 + sw**2) + MW**2*(5 + 8*sw**2)))*(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*(4*MW**2 - MZ**2)) - (MW**2*(cw**3*(-6*MW**3*MZ + 2*MW*MZ**3) + cw**4*(4*MW**4 - 5*MW**2*MZ**2 + MZ**4) + 2*cw*MW*MZ*(3*MW**2 - MZ**2)*sw**2 + (-44*MW**4 + 11*MW**2*MZ**2 + MZ**4)*sw**4 - cw**2*(MW**2 - MZ**2)*(-2*MZ**2*(1 + sw**2) + MW**2*(5 + 8*sw**2)))*(2*MW**2 - MZ**2 - cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*(4*MW**2 - MZ**2)) - (2*MW**2*(-MH**6 + 5*MH**4*MW**2 - 7*MH**2*MW**4 + 5*MW**6)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/(-MH**2 + 4*MW**2) - (2*MW**2*(-MH**6 + 5*MH**4*MW**2 - 7*MH**2*MW**4 + 5*MW**6)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/(-MH**2 + 4*MW**2) + ((MH**6 - 5*MH**4*MW**2 + 7*MH**2*MW**4 - 5*MW**6)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((MH**2 - 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/(MH**2 - 4*MW**2) - ((MH**6 - 5*MH**4*MW**2 + 7*MH**2*MW**4 - 5*MW**6)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/(MH**2 - 4*MW**2)))/(128.*MW**6*cmath.pi**2*sw**2))'+'+'+dMB_GpWcft_UV_EW.value[0]},
                            texname = '\delta Z_{Gp}^{EW}')
 
 
 WWcft_UV_EW = CTParameter(name = 'WWcft_UV_EW',
                           type = 'complex',
-                          value = {-1:'re((ee**2*(-7 + 20*cw**2 - 6*Ncol + 8*sw**2))/(96.*cmath.pi**2*sw**2))',
-                          0:'re(-(ee**2*(-7 + 20*cw**2 - 6*Ncol + 8*sw**2)*reglog(4*cmath.pi))/(96.*cmath.pi**2*sw**2) + (ee**2*((-4*(-18*MW**4*sw**4 + 2*cw**4*(45*MW**2*MZ**2 - 12*MZ**4 + MW**4*(-23 + 30*reglog(cmath.pi) - 60*reglog(2*cmath.pi))) + cw**2*(-3*MH**4 + 9*MH**2*MW**2 - 3*MZ**4 + 6*MT**4*Ncol + 3*MW**2*(3*MZ**2 + MT**2*Ncol) + MW**4*(-1 - 64*sw**2 - 21*reglog(cmath.pi) + 24*sw**2*reglog(cmath.pi) + 6*Ncol*(2 + reglog(64) + 3*reglog(cmath.pi)) + 42*reglog(2*cmath.pi) - 48*sw**2*reglog(2*cmath.pi)))))/(cw**2*MW**4) - (6*(2*MH**6 - 11*MH**4*MW**2 + 24*MH**2*MW**4 - 24*MW**6)*reglog(MU_R**2/MH**2))/(MW**4*(MH**2 - 4*MW**2)) - 24*Ncol*reglog(MU_R**2/MT**2) + (12*(2*cw**4*(MH**2 - 4*MW**2)*(7*MW**4 + 21*MW**2*MZ**2 - 4*MZ**4) + 6*MW**4*(-MH**2 + 4*MW**2)*sw**4 + cw**2*(4*MW**2 - MZ**2)*(MH**4 - 4*MW**2*MZ**2 + MW**4*(10 - 32*sw**2) + MH**2*(MZ**2 + MW**2*(-5 + 8*sw**2))))*reglog(MU_R**2/MW**2))/(cw**2*(MH - 2*MW)*MW**2*(MH + 2*MW)*(2*MW - MZ)*(2*MW + MZ)) + (6*(cw**2*(12*MW**4*MZ**2 - 11*MW**2*MZ**4 + 2*MZ**6) + 4*cw**4*(30*MW**6 + 15*MW**4*MZ**2 - 25*MW**2*MZ**4 + 4*MZ**6) + 12*MW**4*(-2*MW**2 + MZ**2)*sw**4)*reglog(MU_R**2/MZ**2))/(cw**2*MW**4*(4*MW**2 - MZ**2)) + (24*(-MT + MW)*(MT + MW)*(MT**2 - MT*MW + MW**2)*(MT**2 + MT*MW + MW**2)*Ncol*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2))/MW**6 - (6*(4*cw**4*(MH**2 - 4*MW**2)*(3*MW**6 - 46*MW**4*MZ**2 + 29*MW**2*MZ**4 - 4*MZ**6) + cw**2*(4*MW**2 - MZ**2)*(2*MH**6 - 13*MH**4*MW**2 - 4*MW**2*(9*MW**4 - 5*MW**2*MZ**2 + 2*MZ**4) + MH**2*(32*MW**4 - 5*MW**2*MZ**2 + 2*MZ**4)) + 12*MW**4*(MH**2 - 4*MW**2)*(3*MW**2 - MZ**2)*sw**4)*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/(cw**2*(MH - 2*MW)*MW**4*(MH + 2*MW)*(2*MW - MZ)*(2*MW + MZ)) - (6*(4*cw**4*(3*MW**6 - 46*MW**4*MZ**2 + 29*MW**2*MZ**4 - 4*MZ**6) + cw**2*(-20*MW**4*MZ**2 + 13*MW**2*MZ**4 - 2*MZ**6) + 12*MW**4*(3*MW**2 - MZ**2)*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**4*(4*MW**2 - MZ**2)) - (6*(4*cw**4*(3*MW**6 - 46*MW**4*MZ**2 + 29*MW**2*MZ**4 - 4*MZ**6) + cw**2*(-20*MW**4*MZ**2 + 13*MW**2*MZ**4 - 2*MZ**6) + 12*MW**4*(3*MW**2 - MZ**2)*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**4*(4*MW**2 - MZ**2)) + (3*(4*cw**4*(3*MW**6 - 46*MW**4*MZ**2 + 29*MW**2*MZ**4 - 4*MZ**6) + cw**2*(-20*MW**4*MZ**2 + 13*MW**2*MZ**4 - 2*MZ**6) + 12*MW**4*(3*MW**2 - MZ**2)*sw**4)*(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**6*(4*MW**2 - MZ**2)) - (3*(4*cw**4*(3*MW**6 - 46*MW**4*MZ**2 + 29*MW**2*MZ**4 - 4*MZ**6) + cw**2*(-20*MW**4*MZ**2 + 13*MW**2*MZ**4 - 2*MZ**6) + 12*MW**4*(3*MW**2 - MZ**2)*sw**4)*(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**6*(4*MW**2 - MZ**2)) - (6*(2*MH**6 - 13*MH**4*MW**2 + 32*MH**2*MW**4 - 36*MW**6)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/(MW**4*(MH**2 - 4*MW**2)) - (6*(2*MH**6 - 13*MH**4*MW**2 + 32*MH**2*MW**4 - 36*MW**6)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/(MW**4*(MH**2 - 4*MW**2)) - 24*(3 + 2*Ncol)*reglog(-(MU_R**2/(MW**2 + vep*complex(0,1)))) + (3*(2*MH**6 - 13*MH**4*MW**2 + 32*MH**2*MW**4 - 36*MW**6)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((MH**2 - 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/(MW**6*(MH**2 - 4*MW**2)) - (3*(2*MH**6 - 13*MH**4*MW**2 + 32*MH**2*MW**4 - 36*MW**6)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/(MW**6*(MH**2 - 4*MW**2))))/(1152.*cmath.pi**2*sw**2))'+'+'+dMB_WWcft_UV_EW.value[0]},
+                          value = {-1:'recms(CMSParam==1.0 and WW != 0,(ee**2*(-7 + 20*cw**2 - 6*Ncol + 8*sw**2))/(96.*cmath.pi**2*sw**2))',
+                          0:'recms(CMSParam==1.0 and WW != 0, -(ee**2*(-7 + 20*cw**2 - 6*Ncol + 8*sw**2)*reglog(4*cmath.pi))/(96.*cmath.pi**2*sw**2) + (ee**2*((-4*(-18*MW**4*sw**4 + 2*cw**4*(45*MW**2*MZ**2 - 12*MZ**4 + MW**4*(-23 + 30*reglog(cmath.pi) - 60*reglog(2*cmath.pi))) + cw**2*(-3*MH**4 + 9*MH**2*MW**2 - 3*MZ**4 + 6*MT**4*Ncol + 3*MW**2*(3*MZ**2 + MT**2*Ncol) + MW**4*(-1 - 64*sw**2 - 21*reglog(cmath.pi) + 24*sw**2*reglog(cmath.pi) + 6*Ncol*(2 + reglog(64) + 3*reglog(cmath.pi)) + 42*reglog(2*cmath.pi) - 48*sw**2*reglog(2*cmath.pi)))))/(cw**2*MW**4) - (6*(2*MH**6 - 11*MH**4*MW**2 + 24*MH**2*MW**4 - 24*MW**6)*reglog(MU_R**2/MH**2))/(MW**4*(MH**2 - 4*MW**2)) - 24*Ncol*reglog(MU_R**2/MT**2) + (12*(2*cw**4*(MH**2 - 4*MW**2)*(7*MW**4 + 21*MW**2*MZ**2 - 4*MZ**4) + 6*MW**4*(-MH**2 + 4*MW**2)*sw**4 + cw**2*(4*MW**2 - MZ**2)*(MH**4 - 4*MW**2*MZ**2 + MW**4*(10 - 32*sw**2) + MH**2*(MZ**2 + MW**2*(-5 + 8*sw**2))))*reglog(MU_R**2/MW**2))/(cw**2*(MH - 2*MW)*MW**2*(MH + 2*MW)*(2*MW - MZ)*(2*MW + MZ)) + (6*(cw**2*(12*MW**4*MZ**2 - 11*MW**2*MZ**4 + 2*MZ**6) + 4*cw**4*(30*MW**6 + 15*MW**4*MZ**2 - 25*MW**2*MZ**4 + 4*MZ**6) + 12*MW**4*(-2*MW**2 + MZ**2)*sw**4)*reglog(MU_R**2/MZ**2))/(cw**2*MW**4*(4*MW**2 - MZ**2)) + (24*(-MT + MW)*(MT + MW)*(MT**2 - MT*MW + MW**2)*(MT**2 + MT*MW + MW**2)*Ncol*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2))/MW**6 - (6*(4*cw**4*(MH**2 - 4*MW**2)*(3*MW**6 - 46*MW**4*MZ**2 + 29*MW**2*MZ**4 - 4*MZ**6) + cw**2*(4*MW**2 - MZ**2)*(2*MH**6 - 13*MH**4*MW**2 - 4*MW**2*(9*MW**4 - 5*MW**2*MZ**2 + 2*MZ**4) + MH**2*(32*MW**4 - 5*MW**2*MZ**2 + 2*MZ**4)) + 12*MW**4*(MH**2 - 4*MW**2)*(3*MW**2 - MZ**2)*sw**4)*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/(cw**2*(MH - 2*MW)*MW**4*(MH + 2*MW)*(2*MW - MZ)*(2*MW + MZ)) - (6*(4*cw**4*(3*MW**6 - 46*MW**4*MZ**2 + 29*MW**2*MZ**4 - 4*MZ**6) + cw**2*(-20*MW**4*MZ**2 + 13*MW**2*MZ**4 - 2*MZ**6) + 12*MW**4*(3*MW**2 - MZ**2)*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**4*(4*MW**2 - MZ**2)) - (6*(4*cw**4*(3*MW**6 - 46*MW**4*MZ**2 + 29*MW**2*MZ**4 - 4*MZ**6) + cw**2*(-20*MW**4*MZ**2 + 13*MW**2*MZ**4 - 2*MZ**6) + 12*MW**4*(3*MW**2 - MZ**2)*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**4*(4*MW**2 - MZ**2)) + (3*(4*cw**4*(3*MW**6 - 46*MW**4*MZ**2 + 29*MW**2*MZ**4 - 4*MZ**6) + cw**2*(-20*MW**4*MZ**2 + 13*MW**2*MZ**4 - 2*MZ**6) + 12*MW**4*(3*MW**2 - MZ**2)*sw**4)*(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**6*(4*MW**2 - MZ**2)) - (3*(4*cw**4*(3*MW**6 - 46*MW**4*MZ**2 + 29*MW**2*MZ**4 - 4*MZ**6) + cw**2*(-20*MW**4*MZ**2 + 13*MW**2*MZ**4 - 2*MZ**6) + 12*MW**4*(3*MW**2 - MZ**2)*sw**4)*(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**6*(4*MW**2 - MZ**2)) - (6*(2*MH**6 - 13*MH**4*MW**2 + 32*MH**2*MW**4 - 36*MW**6)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/(MW**4*(MH**2 - 4*MW**2)) - (6*(2*MH**6 - 13*MH**4*MW**2 + 32*MH**2*MW**4 - 36*MW**6)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/(MW**4*(MH**2 - 4*MW**2)) - 24*(3 + 2*Ncol)*reglogp(-(MU_R**2/(MW**2 + vep*complex(0,1)))) + (3*(2*MH**6 - 13*MH**4*MW**2 + 32*MH**2*MW**4 - 36*MW**6)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((MH**2 - 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/(MW**6*(MH**2 - 4*MW**2)) - (3*(2*MH**6 - 13*MH**4*MW**2 + 32*MH**2*MW**4 - 36*MW**6)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/(MW**6*(MH**2 - 4*MW**2))))/(1152.*cmath.pi**2*sw**2))'+'+'+dMB_WWcft_UV_EW.value[0]},
                           texname = '\delta Z_{W}^{EW}')
 
 
 ZZWcft_UV_EW = CTParameter(name = 'ZZWcft_UV_EW',
                            type = 'complex',
-                           value = {-1:'re((ee**2*(-39 + 117*cw**4 + 72*sw**2 + 6*cw**2*sw**2 - 147*sw**4 - 4*Ncol*(9 - 18*sw**2 + 20*sw**4)))/(576.*cw**2*cmath.pi**2*sw**2))',
-                           0:'re(-(ee**2*(-39 + 117*cw**4 + 72*sw**2 + 6*cw**2*sw**2 - 147*sw**4 - 4*Ncol*(9 - 18*sw**2 + 20*sw**4))*reglog(4*cmath.pi))/(576.*cw**2*cmath.pi**2*sw**2) + (ee**2*((-2*(-108*MW**2*MZ**2 - 6*cw**4*MZ**2*sw**2*(12*MW**2 + MZ**2*(5 + reglog(64) + 3*reglog(cmath.pi))) + 9*cw**6*(60*MW**2*MZ**2 + MZ**4*(-41 + 39*reglog(cmath.pi) - 78*reglog(2*cmath.pi))) + cw**2*(-18*MH**4 + 54*MH**2*MZ**2 + MZ**2*(2*(-90*MW**2*sw**4 + MT**2*Ncol*(9 + 48*sw**2 - 64*sw**4)) + MZ**2*(4*Ncol*(9 - 18*sw**2 + 20*sw**4)*(2 + reglog(64) + 3*reglog(cmath.pi)) + 3*(29 - 39*reglog(cmath.pi) - 24*sw**2*(2 + reglog(64) + 3*reglog(cmath.pi)) + 78*reglog(2*cmath.pi) + sw**4*(101 - 147*reglog(cmath.pi) + 294*reglog(2*cmath.pi))))))))/MZ**4 - (18*(12*MW**2*MZ**2*(MH**2 - 2*MZ**2) + cw**2*(2*MH**6 - 11*MH**4*MZ**2 + 12*MH**2*MZ**4))*reglog(MU_R**2/MH**2))/(MZ**4*(MH**2 - 4*MZ**2)) - (8*cw**2*MT**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog(MU_R**2/MT**2))/(4*MT**2*MZ**2 - MZ**4) + (36*cw**2*MW**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*reglog(MU_R**2/MW**2))/(4*MW**2*MZ**2 - MZ**4) + (18*(12*MW**2*MZ**2 + cw**2*(2*MH**4 - 9*MH**2*MZ**2 + 4*MZ**4))*reglog(MU_R**2/MZ**2))/(MZ**2*(MH**2 - 4*MZ**2)) + (2*(-108*MW**2*MZ**2*(MH**2 - 3*MZ**2)*(-4*MT**2 + MZ**2)*(-4*MW**2 + MZ**2) + 27*cw**6*MZ**2*(-4*MT**2 + MZ**2)*(-MH**2 + 4*MZ**2)*(40*MW**4 - 26*MW**2*MZ**2 + 13*MZ**4) - 18*cw**4*MZ**2*(MH**2 - 4*MZ**2)*(-4*MT**2 + MZ**2)*(-8*MW**4 - 2*MW**2*MZ**2 + MZ**4)*sw**2 - cw**2*(MH**2 - 4*MZ**2)*(-18*MH**4*(4*MT**2 - MZ**2)*(-4*MW**2 + MZ**2) - 45*MH**2*MZ**2*(-4*MT**2 + MZ**2)*(-4*MW**2 + MZ**2) + MZ**2*(-360*MW**4*MZ**2*sw**4 + 4*MT**4*(4*MW**2 - MZ**2)*Ncol*(-9 - 48*sw**2 + 64*sw**4) - MZ**6*(9*sw**4 + 2*Ncol*(9 - 24*sw**2 + 32*sw**4)) + 2*MW**2*MZ**4*(9*sw**4 + 4*Ncol*(9 - 24*sw**2 + 32*sw**4)) + 4*MT**2*(360*MW**4*sw**4 + MZ**4*(9*sw**4 + Ncol*(9 - 24*sw**2 + 32*sw**4)) - 2*MW**2*MZ**2*(9*sw**4 + 2*Ncol*(9 - 24*sw**2 + 32*sw**4))))))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/((MH - 2*MZ)*MZ**4*(-2*MT + MZ)*(2*MT + MZ)*(-2*MW + MZ)*(2*MW + MZ)*(MH + 2*MZ)) - (18*(12*MW**2*MZ**2*(MH**2 - 3*MZ**2) + cw**2*(2*MH**6 - 13*MH**4*MZ**2 + 20*MH**2*MZ**4))*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/(MZ**4*(MH**2 - 4*MZ**2)) - (18*(12*MW**2*MZ**2*(MH**2 - 3*MZ**2) + cw**2*(2*MH**6 - 13*MH**4*MZ**2 + 20*MH**2*MZ**4))*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/(MZ**4*(MH**2 - 4*MZ**2)) - 4*cw**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - (4*cw**2*Ncol*(-2*MT**2*MZ**2*(9 - 24*sw**2 + 32*sw**4) + MZ**4*(9 - 24*sw**2 + 32*sw**4) + 2*MT**4*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MT**2*MZ**2 - MZ**4) - (4*cw**2*Ncol*(-2*MT**2*MZ**2*(9 - 24*sw**2 + 32*sw**4) + MZ**4*(9 - 24*sw**2 + 32*sw**4) + 2*MT**4*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MT**2*MZ**2 - MZ**4) + (2*cw**2*Ncol*(-2*MT**2*MZ**2*(9 - 24*sw**2 + 32*sw**4) + MZ**4*(9 - 24*sw**2 + 32*sw**4) + 2*MT**4*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/(4*MT**2*MZ**4 - MZ**6) + (2*cw**2*Ncol*(-2*MT**2*MZ**2*(9 - 24*sw**2 + 32*sw**4) + MZ**4*(9 - 24*sw**2 + 32*sw**4) + 2*MT**4*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/(4*MT**2*MZ**4 - MZ**6) + (18*cw**2*(3*cw**4*(40*MW**4 - 26*MW**2*MZ**2 + 13*MZ**4) - 2*cw**2*(8*MW**4 + 2*MW**2*MZ**2 - MZ**4)*sw**2 - (40*MW**4 - 2*MW**2*MZ**2 + MZ**4)*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MW**2*MZ**2 - MZ**4) + (18*cw**2*(3*cw**4*(40*MW**4 - 26*MW**2*MZ**2 + 13*MZ**4) - 2*cw**2*(8*MW**4 + 2*MW**2*MZ**2 - MZ**4)*sw**2 - (40*MW**4 - 2*MW**2*MZ**2 + MZ**4)*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MW**2*MZ**2 - MZ**4) - (9*cw**2*(3*cw**4*(40*MW**4 - 26*MW**2*MZ**2 + 13*MZ**4) - 2*cw**2*(8*MW**4 + 2*MW**2*MZ**2 - MZ**4)*sw**2 - (40*MW**4 - 2*MW**2*MZ**2 + MZ**4)*sw**4)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/(4*MW**2*MZ**4 - MZ**6) + (9*cw**2*(3*cw**4*(40*MW**4 - 26*MW**2*MZ**2 + 13*MZ**4) - 2*cw**2*(8*MW**4 + 2*MW**2*MZ**2 - MZ**4)*sw**2 - (40*MW**4 - 2*MW**2*MZ**2 + MZ**4)*sw**4)*(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/(4*MW**2*MZ**4 - MZ**6) + (9*(12*MW**2*MZ**2*(MH**2 - 3*MZ**2) + cw**2*(2*MH**6 - 13*MH**4*MZ**2 + 20*MH**2*MZ**4))*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((MH**2 - 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/(MZ**6*(MH**2 - 4*MZ**2)) - (9*(12*MW**2*MZ**2*(MH**2 - 3*MZ**2) + cw**2*(2*MH**6 - 13*MH**4*MZ**2 + 20*MH**2*MZ**4))*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/(MZ**6*(MH**2 - 4*MZ**2))))/(3456.*cw**4*cmath.pi**2*sw**2))'+'+'+dMB_ZZWcft_UV_EW.value[0]},
+                           value = {-1:'recms(CMSParam==1.0 and WZ != 0, (ee**2*(-39 + 117*cw**4 + 72*sw**2 + 6*cw**2*sw**2 - 147*sw**4 - 4*Ncol*(9 - 18*sw**2 + 20*sw**4)))/(576.*cw**2*cmath.pi**2*sw**2))',
+                           0:'recms(CMSParam==1.0 and WZ != 0,-(ee**2*(-39 + 117*cw**4 + 72*sw**2 + 6*cw**2*sw**2 - 147*sw**4 - 4*Ncol*(9 - 18*sw**2 + 20*sw**4))*reglog(4*cmath.pi))/(576.*cw**2*cmath.pi**2*sw**2) + (ee**2*((-2*(-108*MW**2*MZ**2 - 6*cw**4*MZ**2*sw**2*(12*MW**2 + MZ**2*(5 + reglog(64) + 3*reglog(cmath.pi))) + 9*cw**6*(60*MW**2*MZ**2 + MZ**4*(-41 + 39*reglog(cmath.pi) - 78*reglog(2*cmath.pi))) + cw**2*(-18*MH**4 + 54*MH**2*MZ**2 + MZ**2*(2*(-90*MW**2*sw**4 + MT**2*Ncol*(9 + 48*sw**2 - 64*sw**4)) + MZ**2*(4*Ncol*(9 - 18*sw**2 + 20*sw**4)*(2 + reglog(64) + 3*reglog(cmath.pi)) + 3*(29 - 39*reglog(cmath.pi) - 24*sw**2*(2 + reglog(64) + 3*reglog(cmath.pi)) + 78*reglog(2*cmath.pi) + sw**4*(101 - 147*reglog(cmath.pi) + 294*reglog(2*cmath.pi))))))))/MZ**4 - (18*(12*MW**2*MZ**2*(MH**2 - 2*MZ**2) + cw**2*(2*MH**6 - 11*MH**4*MZ**2 + 12*MH**2*MZ**4))*reglog(MU_R**2/MH**2))/(MZ**4*(MH**2 - 4*MZ**2)) - (8*cw**2*MT**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog(MU_R**2/MT**2))/(4*MT**2*MZ**2 - MZ**4) + (36*cw**2*MW**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*reglog(MU_R**2/MW**2))/(4*MW**2*MZ**2 - MZ**4) + (18*(12*MW**2*MZ**2 + cw**2*(2*MH**4 - 9*MH**2*MZ**2 + 4*MZ**4))*reglog(MU_R**2/MZ**2))/(MZ**2*(MH**2 - 4*MZ**2)) + (2*(-108*MW**2*MZ**2*(MH**2 - 3*MZ**2)*(-4*MT**2 + MZ**2)*(-4*MW**2 + MZ**2) + 27*cw**6*MZ**2*(-4*MT**2 + MZ**2)*(-MH**2 + 4*MZ**2)*(40*MW**4 - 26*MW**2*MZ**2 + 13*MZ**4) - 18*cw**4*MZ**2*(MH**2 - 4*MZ**2)*(-4*MT**2 + MZ**2)*(-8*MW**4 - 2*MW**2*MZ**2 + MZ**4)*sw**2 - cw**2*(MH**2 - 4*MZ**2)*(-18*MH**4*(4*MT**2 - MZ**2)*(-4*MW**2 + MZ**2) - 45*MH**2*MZ**2*(-4*MT**2 + MZ**2)*(-4*MW**2 + MZ**2) + MZ**2*(-360*MW**4*MZ**2*sw**4 + 4*MT**4*(4*MW**2 - MZ**2)*Ncol*(-9 - 48*sw**2 + 64*sw**4) - MZ**6*(9*sw**4 + 2*Ncol*(9 - 24*sw**2 + 32*sw**4)) + 2*MW**2*MZ**4*(9*sw**4 + 4*Ncol*(9 - 24*sw**2 + 32*sw**4)) + 4*MT**2*(360*MW**4*sw**4 + MZ**4*(9*sw**4 + Ncol*(9 - 24*sw**2 + 32*sw**4)) - 2*MW**2*MZ**2*(9*sw**4 + 2*Ncol*(9 - 24*sw**2 + 32*sw**4))))))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/((MH - 2*MZ)*MZ**4*(-2*MT + MZ)*(2*MT + MZ)*(-2*MW + MZ)*(2*MW + MZ)*(MH + 2*MZ)) - (18*(12*MW**2*MZ**2*(MH**2 - 3*MZ**2) + cw**2*(2*MH**6 - 13*MH**4*MZ**2 + 20*MH**2*MZ**4))*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/(MZ**4*(MH**2 - 4*MZ**2)) - (18*(12*MW**2*MZ**2*(MH**2 - 3*MZ**2) + cw**2*(2*MH**6 - 13*MH**4*MZ**2 + 20*MH**2*MZ**4))*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/(MZ**4*(MH**2 - 4*MZ**2)) - 4*cw**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - (4*cw**2*Ncol*(-2*MT**2*MZ**2*(9 - 24*sw**2 + 32*sw**4) + MZ**4*(9 - 24*sw**2 + 32*sw**4) + 2*MT**4*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MT**2*MZ**2 - MZ**4) - (4*cw**2*Ncol*(-2*MT**2*MZ**2*(9 - 24*sw**2 + 32*sw**4) + MZ**4*(9 - 24*sw**2 + 32*sw**4) + 2*MT**4*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MT**2*MZ**2 - MZ**4) + (2*cw**2*Ncol*(-2*MT**2*MZ**2*(9 - 24*sw**2 + 32*sw**4) + MZ**4*(9 - 24*sw**2 + 32*sw**4) + 2*MT**4*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/(4*MT**2*MZ**4 - MZ**6) + (2*cw**2*Ncol*(-2*MT**2*MZ**2*(9 - 24*sw**2 + 32*sw**4) + MZ**4*(9 - 24*sw**2 + 32*sw**4) + 2*MT**4*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/(4*MT**2*MZ**4 - MZ**6) + (18*cw**2*(3*cw**4*(40*MW**4 - 26*MW**2*MZ**2 + 13*MZ**4) - 2*cw**2*(8*MW**4 + 2*MW**2*MZ**2 - MZ**4)*sw**2 - (40*MW**4 - 2*MW**2*MZ**2 + MZ**4)*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MW**2*MZ**2 - MZ**4) + (18*cw**2*(3*cw**4*(40*MW**4 - 26*MW**2*MZ**2 + 13*MZ**4) - 2*cw**2*(8*MW**4 + 2*MW**2*MZ**2 - MZ**4)*sw**2 - (40*MW**4 - 2*MW**2*MZ**2 + MZ**4)*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/(4*MW**2*MZ**2 - MZ**4) - (9*cw**2*(3*cw**4*(40*MW**4 - 26*MW**2*MZ**2 + 13*MZ**4) - 2*cw**2*(8*MW**4 + 2*MW**2*MZ**2 - MZ**4)*sw**2 - (40*MW**4 - 2*MW**2*MZ**2 + MZ**4)*sw**4)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/(4*MW**2*MZ**4 - MZ**6) + (9*cw**2*(3*cw**4*(40*MW**4 - 26*MW**2*MZ**2 + 13*MZ**4) - 2*cw**2*(8*MW**4 + 2*MW**2*MZ**2 - MZ**4)*sw**2 - (40*MW**4 - 2*MW**2*MZ**2 + MZ**4)*sw**4)*(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/(4*MW**2*MZ**4 - MZ**6) + (9*(12*MW**2*MZ**2*(MH**2 - 3*MZ**2) + cw**2*(2*MH**6 - 13*MH**4*MZ**2 + 20*MH**2*MZ**4))*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((MH**2 - 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/(MZ**6*(MH**2 - 4*MZ**2)) - (9*(12*MW**2*MZ**2*(MH**2 - 3*MZ**2) + cw**2*(2*MH**6 - 13*MH**4*MZ**2 + 20*MH**2*MZ**4))*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/(MZ**6*(MH**2 - 4*MZ**2))))/(3456.*cw**4*cmath.pi**2*sw**2))'+'+'+dMB_ZZWcft_UV_EW.value[0]},
                            texname = '\delta Z_{ZZ}^{EW}')
 
 
 AZWcft_UV_EW = CTParameter(name = 'AZWcft_UV_EW',
                            type = 'complex',
-                           value = {-1:'re(-(ee**2*(cw**2*(36*MW**2 + 57*MZ**2) + 36*MW**2*sw**2 + MZ**2*(-18 - 18*Ncol + 75*sw**2 + 40*Ncol*sw**2)))/(144.*cw*MZ**2*cmath.pi**2*sw))',
-                           0:'re((ee**2*(cw**2*(36*MW**2 + 57*MZ**2) + 36*MW**2*sw**2 + MZ**2*(-18 - 18*Ncol + 75*sw**2 + 40*Ncol*sw**2))*reglog(4*cmath.pi))/(144.*cw*MZ**2*cmath.pi**2*sw) + (ee**2*((2*(4*(-4*MT**2*Ncol*(-3 + 8*sw**2) + 9*MW**2*sw**2*(-4 - reglog(64) - 3*reglog(cmath.pi))) + MZ**2*(-2*Ncol*(-9 + 20*sw**2)*(5 + reglog(64) + 3*reglog(cmath.pi)) + 3*(6*(5 + reglog(64) + 3*reglog(cmath.pi)) + sw**2*(-128 + 75*reglog(cmath.pi) - 150*reglog(2*cmath.pi)))) + 3*cw**2*(12*MW**2*(-16 - reglog(64) - 3*reglog(cmath.pi)) + MZ**2*(-116 + 57*reglog(cmath.pi) - 114*reglog(2*cmath.pi)))))/MZ**2 + (16*MT**2*Ncol*(-3 + 8*sw**2)*reglog(MU_R**2/MT**2))/MZ**2 + (72*MW**2*(5*cw**2 - sw**2)*reglog(MU_R**2/MW**2))/MZ**2 + (2*(9*cw**2*(32*MW**2 + 19*MZ**2) - 12*MZ**2*Ncol + 72*MW**2*sw**2 + 9*MZ**2*sw**2 + 32*MZ**2*Ncol*sw**2 + 8*MT**2*Ncol*(-3 + 8*sw**2))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/MZ**2 - 4*(-27 - 21*Ncol + 108*sw**2 + 44*Ncol*sw**2)*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) + (8*(2*MT**2 + MZ**2)*Ncol*(-3 + 8*sw**2)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 + (8*(2*MT**2 + MZ**2)*Ncol*(-3 + 8*sw**2)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 - (4*(2*MT**2 + MZ**2)*Ncol*(-3 + 8*sw**2)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**4 - (4*(2*MT**2 + MZ**2)*Ncol*(-3 + 8*sw**2)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**4 + (18*(cw**2*(32*MW**2 + 19*MZ**2) + (8*MW**2 + MZ**2)*sw**2)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 + (18*(cw**2*(32*MW**2 + 19*MZ**2) + (8*MW**2 + MZ**2)*sw**2)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 - (9*(cw**2*(32*MW**2 + 19*MZ**2) + (8*MW**2 + MZ**2)*sw**2)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**4 - (9*(cw**2*(32*MW**2 + 19*MZ**2) + (8*MW**2 + MZ**2)*sw**2)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**4))/(864.*cw*cmath.pi**2*sw))'+'+'+dMB_AZWcft_UV_EW.value[0]},
+                           value = {-1:'recms(CMSParam==1.0 and WZ != 0, -(ee**2*(cw**2*(36*MW**2 + 57*MZ**2) + 36*MW**2*sw**2 + MZ**2*(-18 - 18*Ncol + 75*sw**2 + 40*Ncol*sw**2)))/(144.*cw*MZ**2*cmath.pi**2*sw))',
+                           0:'recms(CMSParam==1.0 and WZ != 0,(ee**2*(cw**2*(36*MW**2 + 57*MZ**2) + 36*MW**2*sw**2 + MZ**2*(-18 - 18*Ncol + 75*sw**2 + 40*Ncol*sw**2))*reglog(4*cmath.pi))/(144.*cw*MZ**2*cmath.pi**2*sw) + (ee**2*((2*(4*(-4*MT**2*Ncol*(-3 + 8*sw**2) + 9*MW**2*sw**2*(-4 - reglog(64) - 3*reglog(cmath.pi))) + MZ**2*(-2*Ncol*(-9 + 20*sw**2)*(5 + reglog(64) + 3*reglog(cmath.pi)) + 3*(6*(5 + reglog(64) + 3*reglog(cmath.pi)) + sw**2*(-128 + 75*reglog(cmath.pi) - 150*reglog(2*cmath.pi)))) + 3*cw**2*(12*MW**2*(-16 - reglog(64) - 3*reglog(cmath.pi)) + MZ**2*(-116 + 57*reglog(cmath.pi) - 114*reglog(2*cmath.pi)))))/MZ**2 + (16*MT**2*Ncol*(-3 + 8*sw**2)*reglog(MU_R**2/MT**2))/MZ**2 + (72*MW**2*(5*cw**2 - sw**2)*reglog(MU_R**2/MW**2))/MZ**2 + (2*(9*cw**2*(32*MW**2 + 19*MZ**2) - 12*MZ**2*Ncol + 72*MW**2*sw**2 + 9*MZ**2*sw**2 + 32*MZ**2*Ncol*sw**2 + 8*MT**2*Ncol*(-3 + 8*sw**2))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/MZ**2 - 4*(-27 - 21*Ncol + 108*sw**2 + 44*Ncol*sw**2)*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) + (8*(2*MT**2 + MZ**2)*Ncol*(-3 + 8*sw**2)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 + (8*(2*MT**2 + MZ**2)*Ncol*(-3 + 8*sw**2)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 - (4*(2*MT**2 + MZ**2)*Ncol*(-3 + 8*sw**2)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**4 - (4*(2*MT**2 + MZ**2)*Ncol*(-3 + 8*sw**2)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**4 + (18*(cw**2*(32*MW**2 + 19*MZ**2) + (8*MW**2 + MZ**2)*sw**2)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 + (18*(cw**2*(32*MW**2 + 19*MZ**2) + (8*MW**2 + MZ**2)*sw**2)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)))/MZ**2 - (9*(cw**2*(32*MW**2 + 19*MZ**2) + (8*MW**2 + MZ**2)*sw**2)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**4 - (9*(cw**2*(32*MW**2 + 19*MZ**2) + (8*MW**2 + MZ**2)*sw**2)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**4))/(864.*cw*cmath.pi**2*sw))'+'+'+dMB_AZWcft_UV_EW.value[0]},
                            texname = '\delta Z_{AZ}^{EW}')
 
 ZAWcft_UV_EW = CTParameter(name = 'ZAWcft_UV_EW',
@@ -544,21 +551,21 @@
 eCoup_UV_EW = CTParameter(name = 'eCoup_UV_EW',
                           type = 'complex',
                           value = {-1:'(ee**2*(cw**2*(-36*MW**2 + MZ**2*(9 + 20*Ncol)) - 36*MW**2*sw**2))/(288.*cw**2*MZ**2*cmath.pi**2)',
-                          0:'re((ee**2*(162*MW**2*(cw**2 + sw**2)*reglog(MW**2/MU_R**2) + cw**2*MZ**2*(243 + 110*Ncol - 48*Ncol*reglog(MT/MU_R) + 243*reglog(MW/MU_R) + 162*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) + 66*Ncol*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))))))/(1296.*cw**2*MZ**2*cmath.pi**2))'+'+'+dMB_eCoup_UV_EW.value[0]},
+                          0:'recms(CMSParam==1.0,(ee**2*(162*MW**2*(cw**2 + sw**2)*reglog(MW**2/MU_R**2) + cw**2*MZ**2*(243 + 110*Ncol - 48*Ncol*reglog(MT/MU_R) + 243*reglog(MW/MU_R) + 162*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) + 66*Ncol*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))))))/(1296.*cw**2*MZ**2*cmath.pi**2))'+'+'+dMB_eCoup_UV_EW.value[0]},
                           texname = '\delta e')
 
 
 SWCoup_UV_EW = CTParameter(name = 'SWCoup_UV_EW',
                            type = 'complex',
-                           value = {-1:'re(-(ee**2*(-18*(2*cw**6*MZ**4 + cw**4*MT**2*MZ**2*Ncol) + 36*MW**4*(-1 + 2*cw**6 - 2*cw**2*sw**4) + cw**2*MW**2*(18*MT**2*Ncol - MZ**2*(39 + 147*cw**4 - 72*sw**2 + 111*sw**4 - 6*cw**2*(31 + 6*Ncol - 37*sw**2) + 4*Ncol*(9 - 18*sw**2 + 20*sw**4)))))/(1152.*cw**2*MW**2*MZ**2*cmath.pi**2*sw**3))'+'+'+dMB_SWCoup_UV_EW.value[-1],
-                           0:'re((ee**2*(-18*(2*cw**6*MZ**4 + cw**4*MT**2*MZ**2*Ncol) + 36*MW**4*(-1 + 2*cw**6 - 2*cw**2*sw**4) + cw**2*MW**2*(18*MT**2*Ncol - MZ**2*(39 + 147*cw**4 - 72*sw**2 + 111*sw**4 - 6*cw**2*(31 + 6*Ncol - 37*sw**2) + 4*Ncol*(9 - 18*sw**2 + 20*sw**4))))*reglog(4*cmath.pi))/(1152.*cw**2*MW**2*MZ**2*cmath.pi**2*sw**3) + (cw**2*(-(ee**2*((2*(cw**2*(3*MH**4 - 18*MH**2*MW**2 + 3*(MZ**4 - 2*MT**4*Ncol) - 6*MW**2*(3*MZ**2 + MT**2*Ncol*(2 + reglog(64) + 3*reglog(cmath.pi))) - 2*MW**4*(-83 + 178*sw**2 + 93*reglog(cmath.pi) - 114*sw**2*reglog(cmath.pi) - 6*Ncol*(5 + reglog(64) + 3*reglog(cmath.pi)) - 186*reglog(2*cmath.pi) + 228*sw**2*reglog(2*cmath.pi))) + 4*cw**4*(6*MZ**4 + MW**4*(-107 + 66*reglog(cmath.pi) - 132*reglog(2*cmath.pi)) + 9*MW**2*MZ**2*(-6 - reglog(4*cmath.pi))) + 36*MW**4*sw**4*(2 + reglog(4*cmath.pi))))/(cw**2*MW**2) - (6*MH**2*(MH**2 - 3*MW**2)*reglog(MU_R**2/MH**2))/MW**2 - 12*(3*MT**2 - 2*MW**2)*Ncol*reglog(MU_R**2/MT**2) + 6*(MH**2 + (1 + 8*cw**2)*MZ**2 + MW**2*(38 - 28*cw**2 - 76*sw**2))*reglog(MU_R**2/MW**2) - (6*(1 + 8*cw**2)*MZ**2*(-3*MW**2 + MZ**2)*reglog(MU_R**2/MZ**2))/MW**2 - (12*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*Ncol*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2))/MW**4 + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) - cw**2*(MH**4 - 4*MH**2*MW**2 + 12*MW**4 - 4*MW**2*MZ**2 + MZ**4) - 12*MW**4*sw**4)*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/(cw**2*MW**2) + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**2) + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**2) - (3*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**4) + (3*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**4) - (6*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/MW**2 - (6*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/MW**2 + 24*MW**2*(3 + 2*Ncol)*reglog(-(MU_R**2/(MW**2 + vep*complex(0,1)))) + (3*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((MH**2 - 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/MW**4 - (3*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/MW**4))/(1152.*MW**2*cmath.pi**2*sw**2) + (ee**2*((2*(-108*MW**2*MZ**2*(-2 + reglog(1/(4.*cmath.pi))) + 6*cw**4*MZ**2*sw**2*(24*MW**2 + MZ**2*(-8 - reglog(64) - 3*reglog(cmath.pi))) + 9*cw**6*MZ**2*(24*MW**2*(-5 + reglog(1/(4.*cmath.pi))) + MZ**2*(-80 + 39*reglog(cmath.pi) - 78*reglog(2*cmath.pi))) + cw**2*(9*MH**4 - 54*MH**2*MZ**2 + MZ**2*(2*(-36*MW**2*sw**4*(-5 - reglog(64) - 3*reglog(cmath.pi)) + MT**2*Ncol*(-96*sw**2 + 128*sw**4 - 9*(2 + reglog(64) + 3*reglog(cmath.pi)))) + MZ**2*(4*Ncol*(9 - 18*sw**2 + 20*sw**4)*(5 + reglog(64) + 3*reglog(cmath.pi)) + 3*(59 - 39*reglog(cmath.pi) - 24*sw**2*(5 + reglog(64) + 3*reglog(cmath.pi)) + 78*reglog(2*cmath.pi) + sw**4*(248 - 147*reglog(cmath.pi) + 294*reglog(2*cmath.pi))))))))/MZ**2 - (18*cw**2*MH**2*(MH**2 - 3*MZ**2)*reglog(MU_R**2/MH**2))/MZ**2 - 8*cw**2*MT**2*Ncol*(9 - 24*sw**2 + 32*sw**4)*reglog(MU_R**2/MT**2) + 72*cw**2*MW**2*(9*cw**4 - 2*cw**2*sw**2 + sw**4)*reglog(MU_R**2/MW**2) + 18*cw**2*(MH**2 + MZ**2)*reglog(MU_R**2/MZ**2) + (2*(-108*MW**2*MZ**2 + 27*cw**6*(20*MW**2*MZ**2 + 13*MZ**4) + 18*cw**4*MZ**2*(-4*MW**2 + MZ**2)*sw**2 - cw**2*(9*MH**4 - 36*MH**2*MZ**2 + MZ**2*(180*MW**2*sw**4 + 2*MT**2*Ncol*(-9 - 48*sw**2 + 64*sw**4) + MZ**2*(9*sw**4 + 2*Ncol*(9 - 24*sw**2 + 32*sw**4)))))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/MZ**2 - (18*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/MZ**2 - (18*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/MZ**2 + 4*cw**2*MZ**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 4*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - 4*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (2*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (2*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + 18*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + 18*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - (9*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 - (9*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (9*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((MH**2 - 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/MZ**4 - (9*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/MZ**4))/(3456.*cw**4*MZ**2*cmath.pi**2*sw**2)))/(2.*sw))'+'+'+dMB_SWCoup_UV_EW.value[0]},
+                           value = {-1:'recms(CMSParam==1.0 and (WW != 0 or WZ != 0),-(ee**2*(-18*(2*cw**6*MZ**4 + cw**4*MT**2*MZ**2*Ncol) + 36*MW**4*(-1 + 2*cw**6 - 2*cw**2*sw**4) + cw**2*MW**2*(18*MT**2*Ncol - MZ**2*(39 + 147*cw**4 - 72*sw**2 + 111*sw**4 - 6*cw**2*(31 + 6*Ncol - 37*sw**2) + 4*Ncol*(9 - 18*sw**2 + 20*sw**4)))))/(1152.*cw**2*MW**2*MZ**2*cmath.pi**2*sw**3))'+'+'+dMB_SWCoup_UV_EW.value[-1],
+                           0:'recms(CMSParam==1.0 and (WW != 0 or WZ != 0),(ee**2*(-18*(2*cw**6*MZ**4 + cw**4*MT**2*MZ**2*Ncol) + 36*MW**4*(-1 + 2*cw**6 - 2*cw**2*sw**4) + cw**2*MW**2*(18*MT**2*Ncol - MZ**2*(39 + 147*cw**4 - 72*sw**2 + 111*sw**4 - 6*cw**2*(31 + 6*Ncol - 37*sw**2) + 4*Ncol*(9 - 18*sw**2 + 20*sw**4))))*reglog(4*cmath.pi))/(1152.*cw**2*MW**2*MZ**2*cmath.pi**2*sw**3) + (cw**2*(-(ee**2*((2*(cw**2*(3*MH**4 - 18*MH**2*MW**2 + 3*(MZ**4 - 2*MT**4*Ncol) - 6*MW**2*(3*MZ**2 + MT**2*Ncol*(2 + reglog(64) + 3*reglog(cmath.pi))) - 2*MW**4*(-83 + 178*sw**2 + 93*reglog(cmath.pi) - 114*sw**2*reglog(cmath.pi) - 6*Ncol*(5 + reglog(64) + 3*reglog(cmath.pi)) - 186*reglog(2*cmath.pi) + 228*sw**2*reglog(2*cmath.pi))) + 4*cw**4*(6*MZ**4 + MW**4*(-107 + 66*reglog(cmath.pi) - 132*reglog(2*cmath.pi)) + 9*MW**2*MZ**2*(-6 - reglog(4*cmath.pi))) + 36*MW**4*sw**4*(2 + reglog(4*cmath.pi))))/(cw**2*MW**2) - (6*MH**2*(MH**2 - 3*MW**2)*reglog(MU_R**2/MH**2))/MW**2 - 12*(3*MT**2 - 2*MW**2)*Ncol*reglog(MU_R**2/MT**2) + 6*(MH**2 + (1 + 8*cw**2)*MZ**2 + MW**2*(38 - 28*cw**2 - 76*sw**2))*reglog(MU_R**2/MW**2) - (6*(1 + 8*cw**2)*MZ**2*(-3*MW**2 + MZ**2)*reglog(MU_R**2/MZ**2))/MW**2 - (12*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*Ncol*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2))/MW**4 + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) - cw**2*(MH**4 - 4*MH**2*MW**2 + 12*MW**4 - 4*MW**2*MZ**2 + MZ**4) - 12*MW**4*sw**4)*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/(cw**2*MW**2) + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**2) + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**2) - (3*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**4) + (3*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**4) - (6*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/MW**2 - (6*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/MW**2 + 24*MW**2*(3 + 2*Ncol)*reglogp(-(MU_R**2/(MW**2 + vep*complex(0,1)))) + (3*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((MH**2 - 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/MW**4 - (3*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/MW**4))/(1152.*MW**2*cmath.pi**2*sw**2) + (ee**2*((2*(-108*MW**2*MZ**2*(-2 + reglog(1/(4.*cmath.pi))) + 6*cw**4*MZ**2*sw**2*(24*MW**2 + MZ**2*(-8 - reglog(64) - 3*reglog(cmath.pi))) + 9*cw**6*MZ**2*(24*MW**2*(-5 + reglog(1/(4.*cmath.pi))) + MZ**2*(-80 + 39*reglog(cmath.pi) - 78*reglog(2*cmath.pi))) + cw**2*(9*MH**4 - 54*MH**2*MZ**2 + MZ**2*(2*(-36*MW**2*sw**4*(-5 - reglog(64) - 3*reglog(cmath.pi)) + MT**2*Ncol*(-96*sw**2 + 128*sw**4 - 9*(2 + reglog(64) + 3*reglog(cmath.pi)))) + MZ**2*(4*Ncol*(9 - 18*sw**2 + 20*sw**4)*(5 + reglog(64) + 3*reglog(cmath.pi)) + 3*(59 - 39*reglog(cmath.pi) - 24*sw**2*(5 + reglog(64) + 3*reglog(cmath.pi)) + 78*reglog(2*cmath.pi) + sw**4*(248 - 147*reglog(cmath.pi) + 294*reglog(2*cmath.pi))))))))/MZ**2 - (18*cw**2*MH**2*(MH**2 - 3*MZ**2)*reglog(MU_R**2/MH**2))/MZ**2 - 8*cw**2*MT**2*Ncol*(9 - 24*sw**2 + 32*sw**4)*reglog(MU_R**2/MT**2) + 72*cw**2*MW**2*(9*cw**4 - 2*cw**2*sw**2 + sw**4)*reglog(MU_R**2/MW**2) + 18*cw**2*(MH**2 + MZ**2)*reglog(MU_R**2/MZ**2) + (2*(-108*MW**2*MZ**2 + 27*cw**6*(20*MW**2*MZ**2 + 13*MZ**4) + 18*cw**4*MZ**2*(-4*MW**2 + MZ**2)*sw**2 - cw**2*(9*MH**4 - 36*MH**2*MZ**2 + MZ**2*(180*MW**2*sw**4 + 2*MT**2*Ncol*(-9 - 48*sw**2 + 64*sw**4) + MZ**2*(9*sw**4 + 2*Ncol*(9 - 24*sw**2 + 32*sw**4)))))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/MZ**2 - (18*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/MZ**2 - (18*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/MZ**2 + 4*cw**2*MZ**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 4*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - 4*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (2*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (2*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + 18*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + 18*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - (9*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 - (9*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (9*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((MH**2 - 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/MZ**4 - (9*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/MZ**4))/(3456.*cw**4*MZ**2*cmath.pi**2*sw**2)))/(2.*sw))'+'+'+dMB_SWCoup_UV_EW.value[0]},
                            texname = '\delta SW')
 
 
 CWCoup_UV_EW = CTParameter(name = 'CWCoup_UV_EW',
                            type = 'complex',
-                           value = {-1:'re((ee**2*(-18*(2*cw**6*MZ**4 + cw**4*MT**2*MZ**2*Ncol) + 36*MW**4*(-1 + 2*cw**6 - 2*cw**2*sw**4) + cw**2*MW**2*(18*MT**2*Ncol - MZ**2*(39 + 147*cw**4 - 72*sw**2 + 111*sw**4 - 6*cw**2*(31 + 6*Ncol - 37*sw**2) + 4*Ncol*(9 - 18*sw**2 + 20*sw**4)))))/(1152.*cw**3*MW**2*MZ**2*cmath.pi**2*sw**2))'+'+'+dMB_CWCoup_UV_EW.value[-1],
-                           0:'re(-(ee**2*(-18*(2*cw**6*MZ**4 + cw**4*MT**2*MZ**2*Ncol) + 36*MW**4*(-1 + 2*cw**6 - 2*cw**2*sw**4) + cw**2*MW**2*(18*MT**2*Ncol - MZ**2*(39 + 147*cw**4 - 72*sw**2 + 111*sw**4 - 6*cw**2*(31 + 6*Ncol - 37*sw**2) + 4*Ncol*(9 - 18*sw**2 + 20*sw**4))))*reglog(4*cmath.pi))/(1152.*cw**3*MW**2*MZ**2*cmath.pi**2*sw**2) + (cw*((ee**2*((2*(cw**2*(3*MH**4 - 18*MH**2*MW**2 + 3*(MZ**4 - 2*MT**4*Ncol) - 6*MW**2*(3*MZ**2 + MT**2*Ncol*(2 + reglog(64) + 3*reglog(cmath.pi))) - 2*MW**4*(-83 + 178*sw**2 + 93*reglog(cmath.pi) - 114*sw**2*reglog(cmath.pi) - 6*Ncol*(5 + reglog(64) + 3*reglog(cmath.pi)) - 186*reglog(2*cmath.pi) + 228*sw**2*reglog(2*cmath.pi))) + 4*cw**4*(6*MZ**4 + MW**4*(-107 + 66*reglog(cmath.pi) - 132*reglog(2*cmath.pi)) + 9*MW**2*MZ**2*(-6 - reglog(4*cmath.pi))) + 36*MW**4*sw**4*(2 + reglog(4*cmath.pi))))/(cw**2*MW**2) - (6*MH**2*(MH**2 - 3*MW**2)*reglog(MU_R**2/MH**2))/MW**2 - 12*(3*MT**2 - 2*MW**2)*Ncol*reglog(MU_R**2/MT**2) + 6*(MH**2 + (1 + 8*cw**2)*MZ**2 + MW**2*(38 - 28*cw**2 - 76*sw**2))*reglog(MU_R**2/MW**2) - (6*(1 + 8*cw**2)*MZ**2*(-3*MW**2 + MZ**2)*reglog(MU_R**2/MZ**2))/MW**2 - (12*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*Ncol*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2))/MW**4 + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) - cw**2*(MH**4 - 4*MH**2*MW**2 + 12*MW**4 - 4*MW**2*MZ**2 + MZ**4) - 12*MW**4*sw**4)*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/(cw**2*MW**2) + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**2) + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**2) - (3*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**4) + (3*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**4) - (6*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/MW**2 - (6*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/MW**2 + 24*MW**2*(3 + 2*Ncol)*reglog(-(MU_R**2/(MW**2 + vep*complex(0,1)))) + (3*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((MH**2 - 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/MW**4 - (3*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/MW**4))/(1152.*MW**2*cmath.pi**2*sw**2) - (ee**2*((2*(-108*MW**2*MZ**2*(-2 + reglog(1/(4.*cmath.pi))) + 6*cw**4*MZ**2*sw**2*(24*MW**2 + MZ**2*(-8 - reglog(64) - 3*reglog(cmath.pi))) + 9*cw**6*MZ**2*(24*MW**2*(-5 + reglog(1/(4.*cmath.pi))) + MZ**2*(-80 + 39*reglog(cmath.pi) - 78*reglog(2*cmath.pi))) + cw**2*(9*MH**4 - 54*MH**2*MZ**2 + MZ**2*(2*(-36*MW**2*sw**4*(-5 - reglog(64) - 3*reglog(cmath.pi)) + MT**2*Ncol*(-96*sw**2 + 128*sw**4 - 9*(2 + reglog(64) + 3*reglog(cmath.pi)))) + MZ**2*(4*Ncol*(9 - 18*sw**2 + 20*sw**4)*(5 + reglog(64) + 3*reglog(cmath.pi)) + 3*(59 - 39*reglog(cmath.pi) - 24*sw**2*(5 + reglog(64) + 3*reglog(cmath.pi)) + 78*reglog(2*cmath.pi) + sw**4*(248 - 147*reglog(cmath.pi) + 294*reglog(2*cmath.pi))))))))/MZ**2 - (18*cw**2*MH**2*(MH**2 - 3*MZ**2)*reglog(MU_R**2/MH**2))/MZ**2 - 8*cw**2*MT**2*Ncol*(9 - 24*sw**2 + 32*sw**4)*reglog(MU_R**2/MT**2) + 72*cw**2*MW**2*(9*cw**4 - 2*cw**2*sw**2 + sw**4)*reglog(MU_R**2/MW**2) + 18*cw**2*(MH**2 + MZ**2)*reglog(MU_R**2/MZ**2) + (2*(-108*MW**2*MZ**2 + 27*cw**6*(20*MW**2*MZ**2 + 13*MZ**4) + 18*cw**4*MZ**2*(-4*MW**2 + MZ**2)*sw**2 - cw**2*(9*MH**4 - 36*MH**2*MZ**2 + MZ**2*(180*MW**2*sw**4 + 2*MT**2*Ncol*(-9 - 48*sw**2 + 64*sw**4) + MZ**2*(9*sw**4 + 2*Ncol*(9 - 24*sw**2 + 32*sw**4)))))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/MZ**2 - (18*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/MZ**2 - (18*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/MZ**2 + 4*cw**2*MZ**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglog(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 4*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - 4*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (2*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (2*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + 18*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + 18*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - (9*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 - (9*cw**2*(cw**4*(60*MW**2 + 39*MZ**2) + 2*cw**2*(-4*MW**2 + MZ**2)*sw**2 - (20*MW**2 + MZ**2)*sw**4)*(MZ**2 - cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))*reglog((MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))/(-MZ**2 + cmath.sqrt(MZ**2*(-4*MW**2 + MZ**2 + vep*complex(0,4))))))/MZ**2 + (9*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((MH**2 - 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/MZ**4 - (9*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MZ**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MZ**2 + MZ**2*vep*complex(0,4)))))/MZ**4))/(3456.*cw**4*MZ**2*cmath.pi**2*sw**2)))/2.)'+'+'+dMB_CWCoup_UV_EW.value[0]},
+                           value = {-1:'recms(CMSParam==1.0 and (WW != 0 or WZ != 0),(ee**2*(-18*(2*cw**6*MZ**4 + cw**4*MT**2*MZ**2*Ncol) + 36*MW**4*(-1 + 2*cw**6 - 2*cw**2*sw**4) + cw**2*MW**2*(18*MT**2*Ncol - MZ**2*(39 + 147*cw**4 - 72*sw**2 + 111*sw**4 - 6*cw**2*(31 + 6*Ncol - 37*sw**2) + 4*Ncol*(9 - 18*sw**2 + 20*sw**4)))))/(1152.*cw**3*MW**2*MZ**2*cmath.pi**2*sw**2))'+'+'+dMB_CWCoup_UV_EW.value[-1],
+                           0:'recms(CMSParam==1.0 and (WW != 0 or WZ != 0),-(ee**2*(-18*(2*cw**6*MZ**4 + cw**4*MT**2*MZ**2*Ncol) + 36*MW**4*(-1 + 2*cw**6 - 2*cw**2*sw**4) + cw**2*MW**2*(18*MT**2*Ncol - MZ**2*(39 + 147*cw**4 - 72*sw**2 + 111*sw**4 - 6*cw**2*(31 + 6*Ncol - 37*sw**2) + 4*Ncol*(9 - 18*sw**2 + 20*sw**4))))*reglog(4*cmath.pi))/(1152.*cw**3*MW**2*MZ**2*cmath.pi**2*sw**2) + (cw*((ee**2*((2*(cw**2*(3*MH**4 - 18*MH**2*MW**2 + 3*(MZ**4 - 2*MT**4*Ncol) - 6*MW**2*(3*MZ**2 + MT**2*Ncol*(2 + reglog(64) + 3*reglog(cmath.pi))) - 2*MW**4*(-83 + 178*sw**2 + 93*reglog(cmath.pi) - 114*sw**2*reglog(cmath.pi) - 6*Ncol*(5 + reglog(64) + 3*reglog(cmath.pi)) - 186*reglog(2*cmath.pi) + 228*sw**2*reglog(2*cmath.pi))) + 4*cw**4*(6*MZ**4 + MW**4*(-107 + 66*reglog(cmath.pi) - 132*reglog(2*cmath.pi)) + 9*MW**2*MZ**2*(-6 - reglog(4*cmath.pi))) + 36*MW**4*sw**4*(2 + reglog(4*cmath.pi))))/(cw**2*MW**2) - (6*MH**2*(MH**2 - 3*MW**2)*reglog(MU_R**2/MH**2))/MW**2 - 12*(3*MT**2 - 2*MW**2)*Ncol*reglog(MU_R**2/MT**2) + 6*(MH**2 + (1 + 8*cw**2)*MZ**2 + MW**2*(38 - 28*cw**2 - 76*sw**2))*reglog(MU_R**2/MW**2) - (6*(1 + 8*cw**2)*MZ**2*(-3*MW**2 + MZ**2)*reglog(MU_R**2/MZ**2))/MW**2 - (12*(MT - MW)**2*(MT + MW)**2*(MT**2 + 2*MW**2)*Ncol*reglog((MT**2 - MW**2 + vep*complex(0,-1))/MT**2))/MW**4 + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) - cw**2*(MH**4 - 4*MH**2*MW**2 + 12*MW**4 - 4*MW**2*MZ**2 + MZ**4) - 12*MW**4*sw**4)*reglog((MW**2 + vep*complex(0,-1))/MU_R**2))/(cw**2*MW**2) + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*reglog((-MZ**2 - cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**2) + (6*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2.*MW**2)))/(cw**2*MW**2) - (3*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((-MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(2*MW**2 - MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**4) + (3*(cw**4*(60*MW**4 + 44*MW**2*MZ**2 - 8*MZ**4) + cw**2*(4*MW**2*MZ**2 - MZ**4) - 12*MW**4*sw**4)*(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))*reglog((MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))/(-2*MW**2 + MZ**2 + cmath.sqrt(MZ**4 - 4*MW**2*(MZ**2 + vep*complex(0,-1))))))/(cw**2*MW**4) - (6*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/MW**2 - (6*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MW**2*(MH**2 + vep*complex(0,-1))))/(2.*MW**2)))/MW**2 + 24*MW**2*(3 + 2*Ncol)*reglogp(-(MU_R**2/(MW**2 + vep*complex(0,1)))) + (3*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((MH**2 - 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/MW**4 - (3*(MH**4 - 4*MH**2*MW**2 + 12*MW**4)*(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))*reglog((-MH**2 + 2*MW**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))/(-MH**2 + cmath.sqrt(MH**4 - 4*MH**2*MW**2 + MW**2*vep*complex(0,4)))))/MW**4))/(1152.*MW**2*cmath.pi**2*sw**2) - (ee**2*((2*(-108*MW**2*MZ**2*(-2 + reglog(1/(4.*cmath.pi))) + 6*cw**4*MZ**2*sw**2*(24*MW**2 + MZ**2*(-8 - reglog(64) - 3*reglog(cmath.pi))) + 9*cw**6*MZ**2*(24*MW**2*(-5 + reglog(1/(4.*cmath.pi))) + MZ**2*(-80 + 39*reglog(cmath.pi) - 78*reglog(2*cmath.pi))) + cw**2*(9*MH**4 - 54*MH**2*MZ**2 + MZ**2*(2*(-36*MW**2*sw**4*(-5 - reglog(64) - 3*reglog(cmath.pi)) + MT**2*Ncol*(-96*sw**2 + 128*sw**4 - 9*(2 + reglog(64) + 3*reglog(cmath.pi)))) + MZ**2*(4*Ncol*(9 - 18*sw**2 + 20*sw**4)*(5 + reglog(64) + 3*reglog(cmath.pi)) + 3*(59 - 39*reglog(cmath.pi) - 24*sw**2*(5 + reglog(64) + 3*reglog(cmath.pi)) + 78*reglog(2*cmath.pi) + sw**4*(248 - 147*reglog(cmath.pi) + 294*reglog(2*cmath.pi))))))))/MZ**2 - (18*cw**2*MH**2*(MH**2 - 3*MZ**2)*reglog(MU_R**2/MH**2))/MZ**2 - 8*cw**2*MT**2*Ncol*(9 - 24*sw**2 + 32*sw**4)*reglog(MU_R**2/MT**2) + 72*cw**2*MW**2*(9*cw**4 - 2*cw**2*sw**2 + sw**4)*reglog(MU_R**2/MW**2) + 18*cw**2*(MH**2 + MZ**2)*reglog(MU_R**2/MZ**2) + (2*(-108*MW**2*MZ**2 + 27*cw**6*(20*MW**2*MZ**2 + 13*MZ**4) + 18*cw**4*MZ**2*(-4*MW**2 + MZ**2)*sw**2 - cw**2*(9*MH**4 - 36*MH**2*MZ**2 + MZ**2*(180*MW**2*sw**4 + 2*MT**2*Ncol*(-9 - 48*sw**2 + 64*sw**4) + MZ**2*(9*sw**4 + 2*Ncol*(9 - 24*sw**2 + 32*sw**4)))))*reglog((MZ**2 + vep*complex(0,-1))/MU_R**2))/MZ**2 - (18*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*reglog(-1 + (MH**2 - cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/MZ**2 - (18*(12*MW**2*MZ**2 + cw**2*(MH**4 - 4*MH**2*MZ**2))*reglog(-1 + (MH**2 + cmath.sqrt(MH**4 - 4*MZ**2*(MH**2 + vep*complex(0,-1))))/(2.*MZ**2)))/MZ**2 + 4*cw**2*MZ**2*(54*(1 - 2*sw**2 + 4*sw**4) + Ncol*(45 - 84*sw**2 + 88*sw**4))*reglogp(-(MU_R**2/(MZ**2 + vep*complex(0,1)))) - 4*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 - cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) - 4*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(2.*MZ**2)) + (2*cw**2*Ncol*(MZ**2*(9 - 24*sw**2 + 32*sw**4) + MT**2*(-9 - 48*sw**2 + 64*sw**4))*(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))*reglog((-MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 + vep*complex(0,4))))/(MZ**2 + cmath.sqrt(MZ**2*(-4*MT**2 + MZ**2 +