These are the form versions of the expressions
for pipi scattering as given in LU TP 04-02,
please cite that reference if using these.

There are overall factors which need to be taken into account
when putting them together, see the paper for more information.

   MM4U1 =
       + b0int(mp2,mp2,tt,xmu2) * (  - 2/9*mp2 + 1/18*tt )
 
       + b0int(mk2,mk2,tt,xmu2) * (  - 1/9*mk2 + 1/36*tt );
 
   MM4U2 =
       + b0int(mp2,mp2,tt,xmu2) * (  - 2*mp2*tt + 2*mp2^2 + 1/2*tt^2 );
 
   MM4U0 =
       + b0int(mp2,mp2,ss,xmu2) * (  - 2*mp2*ss + 1/2*mp2^2 + 2*ss^2 )
 
       + b0int(mk2,mk2,ss,xmu2) * ( 3/8*ss^2 )
 
       + b0int(me2,me2,ss,xmu2) * ( 1/6*mp2^2 );
   MM4pol =
       + pi16 * ( 2/3*mp2*mk2 - 1/3*mp2*ss + 2/3*mp2^2 - 1/2*mk2*ss - 1/
         8*ss^2 + 1/24*tmu^2 )
 
       + abmp2 * (  - 4/3*mp2 + ss )
 
       + abmk2 * (  - 2/3*mp2 + 1/2*ss )
 
       - 32*mp2*L1r*ss - 16*mp2*L3r*ss + 16*mp2*L4r*ss + 8*mp2*L5r*ss
          + 32*mp2^2*L1r + 16*mp2^2*L3r - 32*mp2^2*L4r - 16*mp2^2*L5r
          + 32*mp2^2*L6r + 16*mp2^2*L8r + 8*L1r*ss^2 + 2*L2r*ss^2 + 2*
         L2r*tmu^2 + 4*L3r*ss^2;

   MMCCpol =

       + ss*tmu^2 * (
          + 6*CC3
          + 2*CC4
          )

       + ss * (
          - 64*mp2*mk2*CC6
          + 64*mp2*mk2*CC11
          - 256*mp2*mk2*CC13
          + 32*mp2*mk2*CC15
          - 96*mp2^2*CC1
          - 192*mp2^2*CC2
          + 96*mp2^2*CC3
          + 32*mp2^2*CC4
          - 32*mp2^2*CC5
          - 32*mp2^2*CC6
          - 64*mp2^2*CC7
          - 32*mp2^2*CC8
          + 32*mp2^2*CC10
          + 32*mp2^2*CC11
          - 64*mp2^2*CC12
          + 32*mp2^2*CC14
          + 48*mp2^2*CC15
          + 64*mp2^2*CC16
          + 32*mp2^2*CC17
          - 32*mp2^2*CC25
          + 32*mp2^2*CC26
          + 64*mp2^2*CC28
          - 64*mp2^2*CC29
          - 32*mp2^2*CC30
          )

       + ss^2 * (
          + 48*mp2*CC1
          + 96*mp2*CC2
          - 48*mp2*CC3
          - 40*mp2*CC4
          + 8*mp2*CC5
          + 8*mp2*CC6
          + 16*mp2*CC7
          + 8*mp2*CC8
          - 4*mp2*CC10
          - 4*mp2*CC11
          + 8*mp2*CC12
          - 8*mp2*CC13
          - 8*mp2*CC22
          - 8*mp2*CC23
          + 20*mp2*CC25
          + 16*mk2*CC6
          - 8*mk2*CC11
          + 48*mk2*CC13
          )
 
       + ss^3 * (
          - 8*CC1
          - 16*CC2
          + 10*CC3
          + 14*CC4
          )
 
       + tmu^2 * (
          - 8*mp2*CC4
          + 4*mp2*CC10
          + 4*mp2*CC11
          - 8*mp2*CC12
          - 8*mp2*CC13
          + 8*mp2*CC22
          + 8*mp2*CC23
          - 4*mp2*CC25
          + 8*mk2*CC11
          - 16*mk2*CC13
          )
 
       + 64*mp2^2*mk2*CC6
          - 64*mp2^2*mk2*CC11
          + 192*mp2^2*mk2*CC13
          - 64*mp2^2*mk2*CC15
          + 64*mp2^2*mk2*CC20
          + 384*mp2^2*mk2*CC21
          + 64*mp2^2*mk2*CC32
          + 64*mp2^3*CC1
          + 128*mp2^3*CC2
          - 64*mp2^3*CC3
          + 32*mp2^3*CC5
          + 32*mp2^3*CC6
          + 64*mp2^3*CC7
          + 32*mp2^3*CC8
          - 32*mp2^3*CC10
          - 32*mp2^3*CC11
          + 32*mp2^3*CC12
          - 32*mp2^3*CC13
          - 64*mp2^3*CC14
          - 96*mp2^3*CC15
          - 128*mp2^3*CC16
          - 64*mp2^3*CC17
          + 96*mp2^3*CC19
          + 160*mp2^3*CC20
          + 192*mp2^3*CC21
          - 64*mp2^3*CC26
          - 128*mp2^3*CC28
          + 64*mp2^3*CC29
          + 96*mp2^3*CC31
          + 160*mp2^3*CC32
         ;

   MMLLpol =

       + pi16 * (
          + 256/27*mp2*mk2*L2r*ss
          + 1048/81*mp2*mk2*L3r*ss
          - 8*mp2*mk2*L5r*ss
          - 92/9*mp2*L1r*ss^2
          + 28/9*mp2*L1r*tmu^2
          - 386/27*mp2*L2r*ss^2
          - 2/9*mp2*L2r*tmu^2
          - 320/81*mp2*L3r*ss^2
          + 4/3*mp2*L3r*tmu^2
          - 8/3*mp2*L4r*ss^2
          + 8/9*mp2*L4r*tmu^2
          - 2*mp2*L5r*ss^2
          + 2/3*mp2*L5r*tmu^2
          + 128/27*mp2^2*mk2*L2r
          - 736/81*mp2^2*mk2*L3r
          + 32/3*mp2^2*mk2*L5r
          + 176/3*mp2^2*L1r*ss
          + 808/27*mp2^2*L2r*ss
          + 2008/81*mp2^2*L3r*ss
          - 160/9*mp2^2*L4r*ss
          - 16/3*mp2^2*L5r*ss
          - 448/9*mp2^3*L1r
          - 224/27*mp2^3*L2r
          - 1760/81*mp2^3*L3r
          + 256/9*mp2^3*L4r
          + 32/3*mp2^3*L5r
          - 8/3*mk2*L2r*ss^2
          - 8/3*mk2*L3r*ss^2
          + 2/3*mk2*L3r*tmu^2
          + 1/9*L1r*ss*tmu^2
          + 1/3*L1r*ss^3
          + 5/18*L2r*ss*tmu^2
          + 13/6*L2r*ss^3
          + 1/9*L3r*ss^3
          )

       + abme2 * (
          - 16/3*mp2*L1r*ss
          - 16/9*mp2*L2r*ss
          - 40/27*mp2*L3r*ss
          + 32/3*mp2^2*L1r
          + 16/9*mp2^2*L2r
          + 64/27*mp2^2*L3r
          - 16/3*mp2^2*L4r
          - 8/9*mp2^2*L5r
          + 32/3*mp2^2*L7r
          + 16/3*mp2^2*L8r
          )

       + abmp2 * (
          - 32/3*mp2*L1r*ss
          + 184/3*mp2*L2r*ss
          - 16/3*mp2*L3r*ss
          + 64*mp2*L4r*ss
          + 32*mp2*L5r*ss
          + 64*mp2^2*L1r
          - 32*mp2^2*L2r
          + 32*mp2^2*L3r
          - 464/3*mp2^2*L4r
          - 232/3*mp2^2*L5r
          + 160*mp2^2*L6r
          + 80*mp2^2*L8r
          - 12*L1r*ss^2
          + 4*L1r*tmu^2
          - 50/3*L2r*ss^2
          + 38/3*L2r*tmu^2
          - 6*L3r*ss^2
          + 2*L3r*tmu^2
          )
 
       + abmk2 * (
          - 32*mp2*L1r*ss
          + 16/3*mp2*L2r*ss
          - 52/3*mp2*L3r*ss
          + 16*mp2*L4r*ss
          + 16*mp2*L5r*ss
          + 64*mp2^2*L1r
          + 80/3*mp2^2*L3r
          - 64*mp2^2*L4r
          - 104/3*mp2^2*L5r
          + 64*mp2^2*L6r
          + 32*mp2^2*L8r
          - 4/3*L2r*ss^2
          + 4*L2r*tmu^2
          + 5/3*L3r*ss^2
          + 1/3*L3r*tmu^2
          )
 
       + 128*mp2*mk2*L4r*L5r*ss
          - 512*mp2*mk2*L4r*L6r*ss
          + 256*mp2*mk2*L4r^2*ss
          - 256*mp2*mk2*L5r*L6r*ss
          - 256*mp2^2*mk2*L4r*L5r
          + 2048*mp2^2*mk2*L4r*L6r
          + 512*mp2^2*mk2*L4r*L8r
          - 512*mp2^2*mk2*L4r^2
          + 512*mp2^2*mk2*L5r*L6r
          - 1024*mp2^2*mk2*L6r*L8r
          - 2048*mp2^2*mk2*L6r^2
          + 192*mp2^2*L4r*L5r*ss
          - 256*mp2^2*L4r*L6r*ss
          - 256*mp2^2*L4r*L8r*ss
          + 128*mp2^2*L4r^2*ss
          - 128*mp2^2*L5r*L6r*ss
          - 128*mp2^2*L5r*L8r*ss
          + 64*mp2^2*L5r^2*ss
          - 384*mp2^3*L4r*L5r
          + 1024*mp2^3*L4r*L6r
          + 768*mp2^3*L4r*L8r
          - 256*mp2^3*L4r^2
          + 768*mp2^3*L5r*L6r
          + 512*mp2^3*L5r*L8r
          - 128*mp2^3*L5r^2
          - 1536*mp2^3*L6r*L8r
          - 1024*mp2^3*L6r^2
          - 512*mp2^3*L8r^2
         ;

   MM6pol =

       + pi16*abme2 * (
          + 1/36*mp2*ss
          - 1/9*mp2^2
          )

       + pi16*abmp2 * (
          + 8/9*mp2*mk2
          - 89/36*mp2*ss
          + 29/18*mp2^2
          - 2/3*mk2*ss
          + 5/24*ss^2
          - 1/72*tmu^2
          )

       + pi16*abmk2 * (
          + 4/9*mp2*mk2
          - 37/36*mp2*ss
          + 3/4*mp2^2
          - 1/3*mk2*ss
          + 1/24*ss^2
          + 1/72*tmu^2
          )

       + pi16^2 * (
          - 83/216*mp2*mk2*pi^2*ss
          - 1375/432*mp2*mk2*ss
          - 2/9*mp2*mk2^2
          + 13/32*mp2*pi^2*ss^2
          - 19/288*mp2*pi^2*tmu^2
          + 1751/432*mp2*ss^2
          - 289/432*mp2*tmu^2
          + 103/648*mp2^2*mk2*pi^2
          + 167/432*mp2^2*mk2
          - 337/216*mp2^2*pi^2*ss
          - 10933/864*mp2^2*ss
          + 349/324*mp2^3*pi^2
          + 6013/864*mp2^3
          + 1/8*mk2*pi^2*ss^2
          - 1/144*mk2*pi^2*tmu^2
          + 13/12*mk2*ss^2
          - 7/72*mk2*tmu^2
          + 1/6*mk2^2*ss
          - 1/96*ss*tmu^2
          - 11/96*ss^3
          )

       + abme2^2 * (
          + 1/12*mp2*me2^-1*ss
          - 2/9*mp2^2*me2^-1
          )

       + abmp2*abmk2 * (
          - 8/9*mp2
          + 2/3*ss
          )

       + abmp2^2 * (
          + 39/16*mp2^-1*ss^2
          - 19/48*mp2^-1*tmu^2
          + 11/2*mp2
          - 26/3*ss
          )

       + abmk2^2 * (
          - 29/12*mp2*mk2^-1*ss
          - 2/9*mp2
          + 5/4*mp2^2*mk2^-1
          + 3/4*mk2^-1*ss^2
          - 1/24*mk2^-1*tmu^2
          + 1/6*ss
          );

   MMHHpol =

       + hhd(mp2,mp2,mp2,mp2,xmu2) * (
          + 5/2*mp2^2*ss
          - 5/2*mp2^3
          )

       + hhd(mp2,mk2,mk2,mp2,xmu2) * (
          - 15/8*mp2^2*ss
          + 15/8*mp2^3
          )

       + hhd(mp2,me2,me2,mp2,xmu2) * (
          + 1/6*mp2^2*ss
          - 1/6*mp2^3
          )

       + hhd(mk2,mp2,mk2,mp2,xmu2) * (
          + 3*mp2*mk2*ss
          - 3*mp2^2*mk2
          )

       + hhd(mk2,mk2,me2,mp2,xmu2) * (
          - 5/2*mp2^2*ss
          + 5/2*mp2^3
          )

       + hhd(me2,mk2,mk2,mp2,xmu2) * (
          + 3/2*mp2*mk2*ss
          - 3/2*mp2^2*mk2
          + 13/8*mp2^2*ss
          - 13/8*mp2^3
          )

       + hh1d(mp2,mk2,mk2,mp2,xmu2) * (
          + 3*mp2^2*ss
          - 3*mp2^3
          )

       + hh1d(mk2,mk2,me2,mp2,xmu2) * (
          + 2*mp2^2*ss
          - 2*mp2^3
          )

       + hh1d(me2,mk2,mk2,mp2,xmu2) * (
          - 2*mp2^2*ss
          + 2*mp2^3
          )

       + hh21d(mp2,mp2,mp2,mp2,xmu2) * (
          + 9*mp2^2*ss
          - 9*mp2^3
          )

       + hh21d(mp2,mk2,mk2,mp2,xmu2) * (
          - 9/8*mp2^2*ss
          + 9/8*mp2^3
          )

       + hh21d(mk2,mp2,mk2,mp2,xmu2) * (
          + 9*mp2^2*ss
          - 9*mp2^3
          )

       + hh21d(me2,mk2,mk2,mp2,xmu2) * (
          + 27/8*mp2^2*ss
          - 27/8*mp2^3
          )

       + zhh(mp2,mp2,mp2,mp2,xmu2) * (
          + 4*mp2*ss
          - 17/6*mp2^2
          - ss^2
          + 1/3*tmu^2
          )

       + zhh(mp2,mk2,mk2,mp2,xmu2) * (
          - 133/36*mp2*ss
          + 10/3*mp2^2
          - 5/16*ss^2
          + 7/16*tmu^2
          )

       + zhh(mp2,me2,me2,mp2,xmu2) * (
          + 1/18*mp2^2
          )

       + zhh(mk2,mp2,mk2,mp2,xmu2) * (
          - 1/12*mp2*mk2
          + 53/18*mp2*ss
          - 4/3*mp2^2
          + 13/72*mk2*ss
          - 1/4*ss^2
          - 1/4*tmu^2
          )

       + zhh(mk2,mk2,mp2,mp2,xmu2) * (
          + 1/12*mp2*mk2
          - 13/72*mk2*ss
          )

       + zhh(mk2,mk2,me2,mp2,xmu2) * (
          - 7/18*mp2^2
          + 3/16*ss^2
          - 3/16*tmu^2
          )
 
       + zhh(me2,mk2,mk2,mp2,xmu2) * (
          - 11/8*mp2*ss
          + 119/36*mp2^2
          - 45/64*ss^2
          + 27/64*tmu^2
          )
 
       + zhh1(mp2,mk2,mk2,mp2,xmu2) * (
          + 7/4*mp2*ss
          - 3/2*mp2^2
          - 3/16*ss^2
          + 1/16*tmu^2
          )
 
       + zhh1(me2,mk2,mk2,mp2,xmu2) * (
          + 11/8*mp2*ss
          - 15/4*mp2^2
          + 45/64*ss^2
          - 27/64*tmu^2
          )
 
       + zhh21(mp2,mp2,mp2,mp2,xmu2) * (
          + 5*mp2*ss
          - mp2^2
          - 3/2*ss^2
          + 1/2*tmu^2
          )
 
       + zhh21(mp2,mk2,mk2,mp2,xmu2) * (
          - 13/8*mp2*ss
          + 1/8*mp2^2
          + 15/16*ss^2
          - 5/16*tmu^2
          )
 
       + zhh21(mk2,mp2,mk2,mp2,xmu2) * (
          + 253/24*mp2*ss
          - 45/4*mp2^2
          + 3/8*ss^2
          - 1/8*tmu^2
          )
 
       + zhh21(mk2,mk2,mp2,mp2,xmu2) * (
          - 37/24*mp2*ss
          + 17/4*mp2^2
          - 3/2*ss^2
          + 1/2*tmu^2
          )
 
       + zhh21(mk2,mk2,me2,mp2,xmu2) * (
          + 3/2*mp2*ss
          - 9/2*mp2^2
          + 45/32*ss^2
          - 15/32*tmu^2
          )
 
       + zhh21(me2,mk2,mk2,mp2,xmu2) * (
          + 21/8*mp2*ss
          - 3/8*mp2^2
          - 9/8*ss^2
          + 3/8*tmu^2
          );
   MMLLU0 =

       + b0int(mp2,mp2,ss,xmu2) * (
          - 728/3*mp2*L1r*ss^2
          - 376/3*mp2*L2r*ss^2
          - 364/3*mp2*L3r*ss^2
          + 64*mp2*L4r*ss^2
          + 32*mp2*L5r*ss^2
          + 1024/3*mp2^2*L1r*ss
          + 608/3*mp2^2*L2r*ss
          + 512/3*mp2^2*L3r*ss
          - 224*mp2^2*L4r*ss
          - 112*mp2^2*L5r*ss
          + 320*mp2^2*L6r*ss
          + 160*mp2^2*L8r*ss
          - 352/3*mp2^3*L1r
          - 224/3*mp2^3*L2r
          - 176/3*mp2^3*L3r
          + 96*mp2^3*L4r
          + 48*mp2^3*L5r
          - 160*mp2^3*L6r
          - 80*mp2^3*L8r
          + 176/3*L1r*ss^3
          + 112/3*L2r*ss^3
          + 88/3*L3r*ss^3
          )
 
       + b0int(mk2,mk2,ss,xmu2) * (
          + 96*mp2*mk2*L1r*ss
          + 32*mp2*mk2*L2r*ss
          + 32*mp2*mk2*L3r*ss
          - 96*mp2*mk2*L4r*ss
          - 24*mp2*mk2*L5r*ss
          + 96*mp2*mk2*L6r*ss
          + 48*mp2*mk2*L8r*ss
          - 48*mp2*L1r*ss^2
          - 8*mp2*L2r*ss^2
          - 14*mp2*L3r*ss^2
          + 24*mp2*L4r*ss^2
          + 6*mp2*L5r*ss^2
          - 48*mk2*L1r*ss^2
          - 8*mk2*L2r*ss^2
          - 14*mk2*L3r*ss^2
          + 24*mk2*L4r*ss^2
          + 24*L1r*ss^3
          + 8*L2r*ss^3
          + 8*L3r*ss^3
          )
 
       + b0int(me2,me2,ss,xmu2) * (
          - 64/3*mp2*mk2*L1r*ss
          - 32/9*mp2*mk2*L2r*ss
          - 128/27*mp2*mk2*L3r*ss
          + 32/3*mp2*mk2*L4r*ss
          + 8*mp2*L1r*ss^2
          + 8/3*mp2*L2r*ss^2
          + 20/9*mp2*L3r*ss^2
          + 128/3*mp2^2*mk2*L1r
          + 128/9*mp2^2*mk2*L2r
          + 320/27*mp2^2*mk2*L3r
          - 128/3*mp2^2*mk2*L4r
          - 64/9*mp2^2*mk2*L5r
          + 128/3*mp2^2*mk2*L6r
          - 128/3*mp2^2*mk2*L7r
          - 32/3*mp2^2*L1r*ss
          - 16/9*mp2^2*L2r*ss
          - 64/27*mp2^2*L3r*ss
          + 16/3*mp2^2*L4r*ss
          - 32/3*mp2^3*L1r
          - 32/9*mp2^3*L2r
          - 80/27*mp2^3*L3r
          + 32/3*mp2^3*L4r
          + 16/9*mp2^3*L5r
          - 32/3*mp2^3*L6r
          + 128/3*mp2^3*L7r
          + 16*mp2^3*L8r
          );

   MM6U0 =

       + b0int(mp2,mp2,ss,xmu2)*pi16 * (
          + 85/24*mp2*ss^2
          - 25/3*mp2^2*ss
          + 10/3*mp2^3
          - 5/12*ss^3
          )

       + b0int(mp2,mp2,ss,xmu2)^2 * (
          - 3*mp2*ss^2
          + 3/2*mp2^2*ss
          - 1/4*mp2^3
          + 2*ss^3
          )

       + b0int(mp2,mp2,ss,xmu2)*b0int(mk2,mk2,ss,xmu2) * (
          - 3/8*mp2*ss^2
          + 3/4*ss^3
          )

       + b0int(mp2,mp2,ss,xmu2)*b0int(me2,me2,ss,xmu2) * (
          + 1/3*mp2^2*ss
          - 1/6*mp2^3
          )

       + b0int(mp2,mp2,ss,xmu2) * (
          - 20*mp2*ss*abmp2
          - 10*mp2*ss*abmk2
          + 8*mp2^2*abmp2
          + 4*mp2^2*abmk2
          + 8*ss^2*abmp2
          + 4*ss^2*abmk2
          )

       + b0int(mk2,mk2,ss,xmu2)*pi16 * (
          - 2*mp2*mk2*ss
          + 1/2*mp2*ss^2
          + 1/2*mk2*ss^2
          - 1/8*ss^3
          )
 
       + b0int(mk2,mk2,ss,xmu2)^2 * (
          + 9/32*ss^3
          )
 
       + b0int(mk2,mk2,ss,xmu2)*b0int(me2,me2,ss,xmu2) * (
          - 1/3*mp2*mk2*ss
          + 3/8*mp2*ss^2
          )
 
       + b0int(mk2,mk2,ss,xmu2) * (
          - 3/4*mp2*abme2*ss
          - 9/4*mp2*ss*abmp2
          - 3/2*mp2*ss*abmk2
          + 3/2*ss^2*abmp2
          + 3/4*ss^2*abmk2
          )
 
       + b0int(me2,me2,ss,xmu2)*pi16 * (
          + 2/9*mp2*mk2*ss
          - 1/24*mp2*ss^2
          - 8/9*mp2^2*mk2
          + 1/9*mp2^2*ss
          + 2/9*mp2^3
          )
 
       + b0int(me2,me2,ss,xmu2)^2 * (
          + 4/27*mp2^2*mk2
          - 7/108*mp2^3
          )
 
       + b0int(me2,me2,ss,xmu2) * (
          + 2/3*mp2^2*abmp2
          - 2/3*mp2^2*abmk2
          )
 
       + b0eps(mp2,mp2,ss,xmu2)*pi16 * (
          - 10*mp2*mk2*ss
          + 59/4*mp2*ss^2
          + 4*mp2^2*mk2
          - 335/9*mp2^2*ss
          + 136/9*mp2^3
          + 4*mk2*ss^2
          - 3/2*ss^3
          )
 
       + b0eps(mk2,mk2,ss,xmu2)*pi16 * (
          - 6*mp2*mk2*ss
          + 15/8*mp2*ss^2
          - 2*mp2^2*ss
          + 9/4*mk2*ss^2
          - 9/16*ss^3
          )
 
       + b0eps(me2,me2,ss,xmu2)*pi16 * (
          + 1/3*mp2*mk2*ss
          - 1/4*mp2*ss^2
          - 4/3*mp2^2*mk2
          + 2/3*mp2^2*ss
          - 2/9*mp2^3
          );

   MMVVU0 =

       + VV(0,mp2,mp2,mp2,mp2,mp2,ss,mp2,xmu2) * (
          + 4*mp2*ss^2
          - 4*mp2^2*ss
          + mp2^3
          )

       + VV(0,mp2,mp2,mk2,mk2,mp2,ss,mp2,xmu2) * (
          + 1/2*mp2*ss^2
          - 9/4*mp2^2*ss
          + mp2^3
          )

       + VV(0,mp2,mp2,me2,me2,mp2,ss,mp2,xmu2) * (
          + 2/9*mp2^2*ss
          - 1/9*mp2^3
          )

       + VV(0,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          + 9/2*mp2^2*ss
          )

       + VV(0,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          - 3/8*mp2*ss^2
          + 2*mp2^2*ss
          )

       + VV(0,me2,me2,mp2,me2,mp2,ss,mp2,xmu2) * (
          + 2/9*mp2^3
          )

       + VV(0,me2,me2,mk2,mk2,mp2,ss,mp2,xmu2) * (
          + 1/4*mp2^2*ss
          + 1/3*mp2^3
          )

       + VV(11,mp2,mp2,mk2,mk2,mp2,ss,mp2,xmu2) * (
          - mp2*ss^2
          + 9/2*mp2^2*ss
          - 2*mp2^3
          )

       + VV(11,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          + 3*mp2*ss^2
          - 12*mp2^2*ss
          )

       + VV(11,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          + 3/2*mp2*ss^2
          - 6*mp2^2*ss
          )

       + VV(11,me2,me2,mk2,mk2,mp2,ss,mp2,xmu2) * (
          + 1/2*mp2^2*ss
          - 2*mp2^3
          )

       + VV(13,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          + 21/4*mp2*ss^2
          - 9*mp2^2*ss
          - 3/4*ss^3
          )

       + VV(13,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          + 15/4*mp2*ss^2
          - 6*mp2^2*ss
          - 9/16*ss^3
          )

       + VV(14,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          + 6*mp2*ss^2
          - 3/2*ss^3
          )

       + VV(14,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          + 9/2*mp2*ss^2
          - 9/8*ss^3
          )

       + VV(22,mp2,mp2,mp2,mp2,mp2,ss,mp2,xmu2) * (
          - 4*mp2*ss^2
          + 18*mp2^2*ss
          - 8*mp2^3
          )

       + VV(22,mp2,mp2,mk2,mk2,mp2,ss,mp2,xmu2) * (
          + 1/2*mp2*ss^2
          - 9/4*mp2^2*ss
          + mp2^3
          )

       + VV(22,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          - 3*mp2*ss^2
          + 12*mp2^2*ss
          )

       + VV(22,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          - 9/8*mp2*ss^2
          + 9/2*mp2^2*ss
          )

       + VV(22,me2,me2,mk2,mk2,mp2,ss,mp2,xmu2) * (
          - 3/4*mp2^2*ss
          + 3*mp2^3
          )

       + VV(23,mp2,mp2,mp2,mp2,mp2,ss,mp2,xmu2) * (
          - 18*mp2*ss^2
          + 8*mp2^2*ss
          + 4*ss^3
          )

       + VV(23,mp2,mp2,mk2,mk2,mp2,ss,mp2,xmu2) * (
          + 9/4*mp2*ss^2
          - mp2^2*ss
          - 1/2*ss^3
          )

       + VV(23,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          - 12*mp2*ss^2
          + 3*ss^3
          )

       + VV(23,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          - 9/2*mp2*ss^2
          + 9/8*ss^3
          )

       + VV(23,me2,me2,mk2,mk2,mp2,ss,mp2,xmu2) * (
          + 3/4*mp2*ss^2
          - 3*mp2^2*ss
          )

       + VV(26,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          - 6*mp2*ss^2
          + 12*mp2^2*ss
          + 3/4*ss^3
          )

       + VV(26,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          - 9/2*mp2*ss^2
          + 9*mp2^2*ss
          + 9/16*ss^3
          )

       + VV(27,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          - 12*mp2*ss^2
          + 3*ss^3
          )

       + VV(27,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          - 9*mp2*ss^2
          + 9/4*ss^3
          )

       + VV(29,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          - 6*mp2*ss^2
          + 3/2*ss^3
          )

       + VV(29,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          - 9/2*mp2*ss^2
          + 9/8*ss^3
          )

       + VV(210,mp2,mp2,mp2,mp2,mp2,ss,mp2,xmu2) * (
          + 40*mp2*ss
          - 16*mp2^2
          - 16*ss^2
          )

       + VV(210,mp2,mp2,mk2,mk2,mp2,ss,mp2,xmu2) * (
          + 20*mp2*ss
          - 8*mp2^2
          - 8*ss^2
          )

       + VV(210,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          + 9/2*mp2*ss
          - 9/4*ss^2
          )
 
       + VV(210,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          + 9/2*mp2*ss
          - 9/4*ss^2
          )
 
       + VV(211,mp2,mp2,mp2,mp2,mp2,ss,mp2,xmu2) * (
          - 16*mp2*ss^2
          + 40*mp2^2*ss
          - 16*mp2^3
          )
 
       + VV(211,mp2,mp2,mk2,mk2,mp2,ss,mp2,xmu2) * (
          - 8*mp2*ss^2
          + 20*mp2^2*ss
          - 8*mp2^3
          )
 
       + VV(211,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          - 9/4*mp2*ss^2
          + 9/2*mp2^2*ss
          )
 
       + VV(211,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          - 9/4*mp2*ss^2
          + 9/2*mp2^2*ss
          )
 
       + VV(212,mp2,mp2,mp2,mp2,mp2,ss,mp2,xmu2) * (
          + 4*mp2*ss^2
          - 8*ss^3
          )
 
       + VV(212,mp2,mp2,mk2,mk2,mp2,ss,mp2,xmu2) * (
          + 2*mp2*ss^2
          - 4*ss^3
          )
 
       + VV(212,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          - 9/8*ss^3
          )
 
       + VV(212,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          - 9/8*ss^3
          )
 
       + VV(213,mp2,mp2,mp2,mp2,mp2,ss,mp2,xmu2) * (
          + 4*mp2*ss^2
          - 8*ss^3
          )
 
       + VV(213,mp2,mp2,mk2,mk2,mp2,ss,mp2,xmu2) * (
          + 2*mp2*ss^2
          - 4*ss^3
          )
 
       + VV(213,mk2,mk2,mp2,mk2,mp2,ss,mp2,xmu2) * (
          - 9/8*ss^3
          )
 
       + VV(213,mk2,mk2,mk2,me2,mp2,ss,mp2,xmu2) * (
          - 9/8*ss^3
          );

   MMLLU1 =
 
       + b0int(mp2,mp2,tt,xmu2) * (
          + 32/9*mp2*L1r*tt
          - 16/9*mp2*L2r*tt
          + 16/9*mp2*L3r*tt
          + 16/9*mp2*L4r*tt
          + 8/9*mp2*L5r*tt
          - 64/9*mp2^2*L4r
          - 32/9*mp2^2*L5r
          - 8/9*L1r*tt^2
          + 4/9*L2r*tt^2
          - 4/9*L3r*tt^2
          )
 
       + b0int(mk2,mk2,tt,xmu2) * (
          - 16/9*mp2*mk2*L5r
          + 4/9*mp2*L5r*tt
          + 8/9*mk2*L3r*tt
          - 2/9*L3r*tt^2
          );

   MM6U1 =
 
       + b0int(mp2,mp2,tt,xmu2)*pi16 * (
          + 4/27*mp2*mk2
          - 11/27*mp2*tt
          + 28/27*mp2^2
          - 1/27*mk2*tt
          + 1/27*tt^2
          )
 
       + b0int(mp2,mp2,tt,xmu2)^2 * (
          - 2/27*mp2*tt
          + 4/27*mp2^2
          + 1/108*tt^2
          )
 
       + b0int(mp2,mp2,tt,xmu2)*b0int(mk2,mk2,tt,xmu2) * (
          + 4/27*mp2*mk2
          - 1/27*mp2*tt
          - 1/27*mk2*tt
          + 1/108*tt^2
          )
 
       + b0int(mp2,mp2,tt,xmu2) * (
          - 8/27*mp2*abmp2
          - 4/27*mp2*abmk2
          + 2/27*tt*abmp2
          + 1/27*tt*abmk2
          )
 
       + b0int(mk2,mk2,tt,xmu2)*pi16 * (
          + 10/27*mp2*mk2
          - 5/54*mp2*tt
          - 5/54*mk2*tt
          + 2/27*mk2^2
          + 1/54*tt^2
          )
 
       + b0int(mk2,mk2,tt,xmu2)^2 * (
          - 1/54*mk2*tt
          + 1/27*mk2^2
          + 1/432*tt^2
          )
 
       + b0int(mk2,mk2,tt,xmu2) * (
          - 4/27*mk2*abmp2
          - 2/27*mk2*abmk2
          + 1/27*tt*abmp2
          + 1/54*tt*abmk2
          )
 
       + b0eps(mp2,mp2,tt,xmu2)*pi16 * (
          - 7/18*mp2*tt
          + 10/9*mp2^2
          + 1/36*tt^2
          )
 
       + b0eps(mk2,mk2,tt,xmu2)*pi16 * (
          + 1/3*mp2*mk2
          - 1/12*mp2*tt
          - 1/18*mk2*tt
          + 1/72*tt^2
          );
   MMVVU1 =

       + VV(0,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          - 1/3*mp2*tt
          )

       + VV(0,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          - 2/3*mp2*tt
          + 1/6*tt^2
          )

       + VV(0,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          - 1/3*mp2*tt
          + 1/8*tt^2
          )

       + VV(11,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          + 1/3*mp2*tt
          + 1/3*mp2^2
          )

       + VV(11,mp2,mp2,me2,me2,mp2,tt,mp2,xmu2) * (
          + 1/27*mp2^2
          )

       + VV(11,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          + 2/3*mp2*tt
          + mp2^2
          - 1/4*tt^2
          )

       + VV(11,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          + 1/3*mp2*tt
          + 4/9*mp2^2
          - 3/16*tt^2
          )

       + VV(13,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          + 2/3*mp2*tt
          - 1/6*tt^2
          )

       + VV(13,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          + 1/2*mp2*tt
          - 1/8*tt^2
          )

       + VV(14,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          - mp2*tt
          + 1/3*tt^2
          )

       + VV(14,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          - 2/3*mp2*tt
          + 1/4*tt^2
          )

       + VV(22,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          - 4/3*mp2^2
          )

       + VV(22,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          + 2/3*mp2*tt
          - 8/3*mp2^2
          )

       + VV(22,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          + 1/2*mp2*tt
          - 4/3*mp2^2
          )

       + VV(23,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          + 4/3*mp2*tt
          )

       + VV(23,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          + 8/3*mp2*tt
          - 2/3*tt^2
          )

       + VV(23,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          + 4/3*mp2*tt
          - 1/2*tt^2
          )

       + VV(26,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          - 1/6*mp2*tt
          - 2*mp2^2
          + 1/6*tt^2
          )

       + VV(26,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          - 1/6*mp2*tt
          - 4/3*mp2^2
          + 1/8*tt^2
          )

       + VV(27,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          + 2*mp2*tt
          - 2/3*tt^2
          )

       + VV(27,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          + 4/3*mp2*tt
          - 1/2*tt^2
          )

       + VV(29,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          + 11/3*mp2*tt
          - tt^2
          )

       + VV(29,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          + 8/3*mp2*tt
          - 3/4*tt^2
          )

       + VV(31,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          + 4*mp2
          - tt
          )

       + VV(31,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          + 3*mp2
          - 3/4*tt
          )

       + VV(33,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          - 2/3*mp2*tt
          + 4/3*mp2^2
          + 1/12*tt^2
          )

       + VV(33,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          - 1/2*mp2*tt
          + mp2^2
          + 1/16*tt^2
          )

       + VV(213,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          + 8/3*mp2*tt
          - 2/3*tt^2
          )

       + VV(213,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          + 4/3*mp2*tt
          - 1/3*tt^2
          )

       + VV(213,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          + mp2*tt
          - 1/4*tt^2
          )

       + VV(213,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          + mp2*tt
          - 1/4*tt^2
          )

       + VV(311,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          - 2/3*mp2*tt
          + 8/3*mp2^2
          )

       + VV(311,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          - 1/2*mp2*tt
          + 2*mp2^2
          )

       + VV(313,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          - 8/3*mp2*tt
          + 2/3*tt^2
          )

       + VV(313,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          - 2*mp2*tt
          + 1/2*tt^2
          )

       + VV(314,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          - 8/3*mp2*tt
          + 2/3*tt^2
          )

       + VV(314,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          - 2*mp2*tt
          + 1/2*tt^2
          )

       + VV(316,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          - 16/3*mp2*tt
          + 4/3*tt^2
          )

       + VV(316,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          - 4*mp2*tt
          + tt^2
          )

       + VV(317,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          + 8/3*mp2
          - 4/3*tt
          )

       + VV(317,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          + 4/3*mp2
          - 2/3*tt
          )

       + VV(317,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          + mp2
          - 1/2*tt
          )

       + VV(317,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          + mp2
          - 1/2*tt
          )

       + VV(321,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          - 4/3*mp2*tt
          + 8/3*mp2^2
          )

       + VV(321,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          - 2/3*mp2*tt
          + 4/3*mp2^2
          )
 
       + VV(321,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          - 1/2*mp2*tt
          + mp2^2
          )
 
       + VV(321,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          - 1/2*mp2*tt
          + mp2^2
          )
 
       + VV(323,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          - 2/3*tt^2
          )
 
       + VV(323,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          - 1/3*tt^2
          )
 
       + VV(323,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          - 1/4*tt^2
          )
 
       + VV(323,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          - 1/4*tt^2
          )
 
       + VV(325,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          - 8/3*mp2*tt
          )
 
       + VV(325,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          - 4/3*mp2*tt
          )
 
       + VV(325,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          - mp2*tt
          )
 
       + VV(325,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          - mp2*tt
          )
 
       + VV(326,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          - 16/3*mp2*tt
          + 4/3*tt^2
          )
 
       + VV(326,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          - 8/3*mp2*tt
          + 2/3*tt^2
          )
 
       + VV(326,mk2,mk2,mp2,mk2,mp2,tt,mp2,xmu2) * (
          - 2*mp2*tt
          + 1/2*tt^2
          )
 
       + VV(326,mk2,mk2,mk2,me2,mp2,tt,mp2,xmu2) * (
          - 2*mp2*tt
          + 1/2*tt^2
          );

   MMLLU2 =
 
       + b0int(mp2,mp2,tt,xmu2) * (
          + 64/3*mp2*L1r*tt^2
          + 176/3*mp2*L2r*tt^2
          + 32/3*mp2*L3r*tt^2
          + 16*mp2*L4r*tt^2
          + 8*mp2*L5r*tt^2
          - 128/3*mp2^2*L1r*tt
          - 352/3*mp2^2*L2r*tt
          - 64/3*mp2^2*L3r*tt
          - 32*mp2^2*L4r*tt
          - 16*mp2^2*L5r*tt
          - 64*mp2^2*L6r*tt
          - 32*mp2^2*L8r*tt
          + 128/3*mp2^3*L1r
          + 256/3*mp2^3*L2r
          + 64/3*mp2^3*L3r
          + 128*mp2^3*L6r
          + 64*mp2^3*L8r
          - 16/3*L1r*tt^3
          - 32/3*L2r*tt^3
          - 8/3*L3r*tt^3
          );
 
   MM6U2 =

       + b0int(mp2,mp2,tt,xmu2)*pi16 * (
          - 5/6*mp2*tt^2
          + 8/3*mp2^2*tt
          - 8/3*mp2^3
          + 1/12*tt^3
          )
 
       + b0int(mp2,mp2,tt,xmu2)^2 * (
          + 3/2*mp2*tt^2
          - 3*mp2^2*tt
          + 2*mp2^3
          - 1/4*tt^3
          )
 
       + b0int(mp2,mp2,tt,xmu2) * (
          - 8*mp2*tt*abmp2
          - 4*mp2*tt*abmk2
          + 8*mp2^2*abmp2
          + 4*mp2^2*abmk2
          + 2*tt^2*abmp2
          + tt^2*abmk2
          )
 
       + b0eps(mp2,mp2,tt,xmu2)*pi16 * (
          - 4*mp2*mk2*tt
          - 4*mp2*tt^2
          + 4*mp2^2*mk2
          + 73/9*mp2^2*tt
          - 56/9*mp2^3
          + mk2*tt^2
          + 3/4*tt^3
          );


   MMVVU2 =

       + VV(0,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          + mp2*tt^2
          - 7*mp2^2*tt
          + 10*mp2^3
          )

       + VV(0,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          + 1/2*mp2*tt^2
          - 3*mp2^2*tt
          + 4*mp2^3
          )

       + VV(0,mp2,mp2,me2,me2,mp2,tt,mp2,xmu2) * (
          - 1/9*mp2^2*tt
          + 2/9*mp2^3
          )

       + VV(11,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          - 3*mp2*tt^2
          + 18*mp2^2*tt
          - 24*mp2^3
          )

       + VV(11,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          - mp2*tt^2
          + 6*mp2^2*tt
          - 8*mp2^3
          )

       + VV(22,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          + 2*mp2*tt^2
          - 12*mp2^2*tt
          + 16*mp2^3
          )
 
       + VV(22,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          + 1/2*mp2*tt^2
          - 3*mp2^2*tt
          + 4*mp2^3
          )
 
       + VV(23,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          + 12*mp2*tt^2
          - 16*mp2^2*tt
          - 2*tt^3
          )
 
       + VV(23,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          + 3*mp2*tt^2
          - 4*mp2^2*tt
          - 1/2*tt^3
          )
 
       + VV(210,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          + 16*mp2*tt
          - 16*mp2^2
          - 4*tt^2
          )
 
       + VV(210,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          + 8*mp2*tt
          - 8*mp2^2
          - 2*tt^2
          )
 
       + VV(211,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          - 4*mp2*tt^2
          + 16*mp2^2*tt
          - 16*mp2^3
          )
 
       + VV(211,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          - 2*mp2*tt^2
          + 8*mp2^2*tt
          - 8*mp2^3
          )
 
       + VV(212,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          + 4*mp2*tt^2
          - 2*tt^3
          )
 
       + VV(212,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          + 2*mp2*tt^2
          - tt^3
          )
 
       + VV(213,mp2,mp2,mp2,mp2,mp2,tt,mp2,xmu2) * (
          + 4*mp2*tt^2
          - 2*tt^3
          )
 
       + VV(213,mp2,mp2,mk2,mk2,mp2,tt,mp2,xmu2) * (
          + 2*mp2*tt^2
          - tt^3
          );