*FORM by J.Vermaseren,version 3.1(Oct 17 2002) Run at: Thu Jan 19 13:51:31 2006
*    * This FORM code processes the result produced by the (PQint) code:
*    * Simplifications and sums over sea and valence quark indices are
*    * implemented. Includes the possiblilty of producing output intended for
*    * fortran functions and LaTeX.
*    
*    **************************************************************************
*    * comp 1 : Simplification of the pseudoscalar meson mass to NNLO
*    * comp 2 : Simplification of the pseudoscalar meson decay constant to NNLO
*    
*    #define comp "2"
*    #define nfl "3"
*    
*    * The parameters (mode) and (type) select the values of (dval) and (dsea),
*    * according to the tables below:
*    
*    * nfl = 2:
*    * dval + dsea     Mode  Type
*    *****************************
*    *    1 + 1         1     1
*    *    1 + 2         2     1
*    *    2 + 1         4     1
*    *    2 + 2         5     1
*    
*    * nfl = 3:
*    * dval + dsea     Mode  Type
*    *****************************
*    *    1 + 1         2     1
*    *    1 + 2         4     1
*    *    1 + 3         5     1
*    *    2 + 1         2     2
*    *    2 + 2         4     2
*    *    2 + 3         5     2
*    
*    #define mode "5"
*    #define type "2"
*    
*    #define pout "1"
*    #define nsim "0"
*    
*    #-
* Sigma2 loaded
* Sigma4 loaded
* Sigma6 loaded
*
*Time =       2.96 sec    Generated terms =          1
*             F0p2        Terms in output =          1
*                         Bytes used      =         24
*
*Time =       2.96 sec    Generated terms =          7
*             F0p4        Terms in output =          7
*                         Bytes used      =        264
*
*Time =       2.96 sec    Generated terms =        326
*             F0p6        Terms in output =        326
*                         Bytes used      =      15940

L   F0p2timo23 =

       + F0 * (
          + 1
          );

L   F0p4timo23 =

       + F0^-1*L4r * (
          + 12*Xb(1)
          )

       + F0^-1*L5r * (
          + 4*X13
          )

       + Ab(Xpp)*F0^-1 * (
          + 1/6*R(Xpp,Xqq,Xp0,Xe0)
          - 1/12*RC(Xpp)
          )

       + Ab(Xps)*F0^-1 * (
          + 1/4
          )

       + Ab(Xn1)*F0^-1 * (
          - 1/12*RV(Xn1,Xn2,X11,X33)
          )

       + Bb(Xpp,Xpp,0)*F0^-1 * (
          - 1/12*RD(Xpp)
          );

L   F0p6timo23 =

       + F0^-3*pi16*L0r * (
          + 4/9*Xp0*Xe0
          - 1/2*X11*X33
          + X13^2
          - 13/3*Xb(1)*X13
          - 35/18*Xb(2)
          )

       + F0^-3*pi16*L1r * (
          - 2*X13^2
          )

       + F0^-3*pi16*L2r * (
          - 11/3*Xp0*Xe0
          - X13^2
          - 13/3*Xb(2)
          )

       + F0^-3*pi16*L3r * (
          + 4/9*Xp0*Xe0
          - 7/12*X11*X33
          + 11/6*X13^2
          - 17/6*Xb(1)*X13
          - 43/36*Xb(2)
          )

       + F0^-3*pi16^2 * (
          - 15/64*Xp0*Xe0
          - 59/384*X11*X33
          + 65/384*X13^2
          - 1/2*Xb(1)*X13
          - 43/128*Xb(2)
          )

       + F0^-3*L4r*L5r * (
          - 48*Xb(1)*X13
          )

       + F0^-3*L4r^2 * (
          - 72*Xb(1)^2
          )

       + F0^-3*L5r^2 * (
          - 8*X13^2
          )

       + F0^-3*K19r * (
          + 4*Xpp^2
          )

       + F0^-3*K20r * (
          + 24*Xb(1)*X13
          )

       + F0^-3*K21r * (
          + 24*Xb(2)
          )

       + F0^-3*K22r * (
          + 72*Xb(1)^2
          )

       + F0^-3*K23r * (
          + 8*X11*X33
          )

       + Ab(Xpp)*F0^-3*pi16 * (
          - 1/8*Xb(1)*R(Xpp,Xqq,Xp0,Xe0)
          + 1/16*Xb(1)*RC(Xpp)
          - 1/12*R(Xpp,Xqq,Xp0,Xe0)*X13
          + 1/48*RC(Xpp)*Xqq
          + 1/48*RC(Xpp)*X13
          )

       + Ab(Xpp)*F0^-3*L0r * (
          + 8/3*R(Xpp,Xqq,Xp0,Xe0)*Xpp
          + 2/3*RC(Xpp)*Xpp
          + 2/3*RD(Xpp)
          )

       + Ab(Xpp)*F0^-3*L3r * (
          + 2/3*R(Xpp,Xqq,Xp0,Xe0)*Xpp
          + 5/3*RC(Xpp)*Xpp
          + 5/3*RD(Xpp)
          )

       + Ab(Xpp)*F0^-3*L4r * (
          - 2*Xb(1)*R(Xpp,Xqq,Xp0,Xe0)
          + Xb(1)*RC(Xpp)
          )

       + Ab(Xpp)*F0^-3*L5r * (
          - 2/3*R(Xpp,Xqq,Xp0,Xe0)*X13
          - 1/3*RC(Xpp)*X13
          )

       + Ab(Xpp)^2*F0^-3 * (
          + 1/16
          + 1/72*R(Xpp,Xqq,Xp0,Xe0)^2
          - 1/72*R(Xpp,Xqq,Xp0,Xe0)*RC(Xpp)
          + 1/288*RC(Xpp)^2
          )

       + Ab(Xpp)*Ab(Xps)*F0^-3 * (
          - 1/36*R(Xpp,Xqq,Xp0,Xe0)
          - 5/72*R(Xpp,Xss,Xp0,Xe0)
          + 7/144*RC(Xpp)
          )

       + Ab(Xpp)*Ab(Xqs)*F0^-3 * (
          - 1/36*R(Xpp,Xqq,Xp0,Xe0)
          - 1/24*R(Xpp,Xss,Xp0,Xe0)
          - 1/48*RC(Xpp)
          )

       + Ab(Xpp)*Ab(Xn1)*F0^-3 * (
          - 1/72*R(Xpp,Xqq,Xn1,Xn2)*RV(Xn1,Xn2,X11,X33)
          + 1/144*RC(Xpp)*RV(Xn1,Xn2,X11,X33)
          )

       + Ab(Xpp)*Ab(X13)*F0^-3 * (
          + 1/8
          )

       + Ab(Xpp)*Ab(Xst)*F0^-3 * (
          - 1/108*R(Xpp,Xss,Xp0,Xe0)^2*RS(Xtt,Xss,Xss,Xpp,Xpp)
          )

       + Ab(Xpp)*Bb(Xpp,Xpp,0)*F0^-3 * (
          + 1/4*Xpp
          - 1/18*R(Xpp,Xqq,Xp0,Xe0)*RC(Xpp)*Xpp
          - 1/72*R(Xpp,Xqq,Xp0,Xe0)*RD(Xpp)
          + 1/18*RC(Xpp)^2*Xpp
          + 1/144*RC(Xpp)*RD(Xpp)
          )

       + Ab(Xpp)*Bb(Xpp,Xn1,0)*F0^-3 * (
          + 1/18*RS(Xqq,Xn1,Xpp)*RC(Xpp)*RV(Xn1,Xn2,X11,X33)*Xpp
          )

       + Ab(Xpp)*Bb(Xqq,Xqq,0)*F0^-3 * (
          - 1/72*R(Xpp,Xqq,Xp0,Xe0)*RD(Xqq)
          + 1/144*RC(Xpp)*RD(Xqq)
          )

       + Ab(Xpp)*Bb(Xps,Xps,0)*F0^-3 * (
          - 1/12*R(Xpp,Xss,Xp0,Xe0)*Xps
          )

       + Ab(Xpp)*Bb(X11,X33,0)*F0^-3 * (
          - 1/18*R(Xqq,Xpp,Xp0,Xe0)*RC(Xpp)*Xpp
          )

       + Ab(Xpp)*Cb(Xpp,Xpp,Xpp,0)*F0^-3 * (
          + 1/18*RC(Xpp)*RD(Xpp)*Xpp
          )

       + Ab(Xpp,eps)*F0^-3*pi16 * (
          + 1/8*Xb(1)*R(Xpp,Xqq,Xp0,Xe0)
          - 1/16*Xb(1)*RC(Xpp)
          - 1/16*RC(Xpp)*Xpp
          - 1/16*RD(Xpp)
          )

       + Ab(Xps)*F0^-3*pi16 * (
          + 1/16*Xps
          - 3/16*Xqs
          - 3/16*Xb(1)
          )

       + Ab(Xps)*F0^-3*L0r * (
          - 2*Xps
          )

       + Ab(Xps)*F0^-3*L3r * (
          - 5*Xps
          )

       + Ab(Xps)*F0^-3*L4r * (
          - 3*Xb(1)
          )

       + Ab(Xps)*F0^-3*L5r * (
          + X13
          )

       + Ab(Xps)^2*F0^-3 * (
          - 1/32
          )

       + Ab(Xps)*Ab(Xpt)*F0^-3 * (
          - 1/16
          )

       + Ab(Xps)*Ab(Xqt)*F0^-3 * (
          + 1/16
          )

       + Ab(Xps)*Ab(Xn1)*F0^-3 * (
          + 7/144*R(Xn1,Xn2,Xpp,Xpp)
          - 5/72*R(Xn1,Xn2,Xpp,Xss)
          - 1/48*R(Xn1,Xn2,Xqq,Xqq)
          + 5/72*R(Xn1,Xn2,Xqq,Xss)
          - 1/36*R(Xn1,Xn2,X11,X33)
          )

       + Ab(Xps)*Bb(Xpp,Xpp,0)*F0^-3 * (
          + 1/24*R(Xpp,Xss,Xp0,Xe0)*Xpp
          - 5/24*R(Xpp,Xss,Xp0,Xe0)*Xps
          )

       + Ab(Xps)*Bb(Xpp,Xn1,0)*F0^-3 * (
          - 1/18*R(Xn1,Xn2,Xpp,Xss)*RS(Xqq,Xpp,Xn1)*Xpp
          - 1/9*R(Xn1,Xn2,Xpp,Xss)*RS(Xqq,Xpp,Xn1)*Xps
          )

       + Ab(Xps)*Bb(Xqq,Xqq,0)*F0^-3 * (
          - 1/48*RD(Xqq)
          )

       + Ab(Xps)*Bb(X11,X33,0)*F0^-3 * (
          + 1/18*R(Xqq,Xss,Xp0,Xe0)*Xss
          )

       + Ab(Xps)*Bb(X11,X33,0,kk)*F0^-3 * (
          + 1/9*R(Xqq,Xss,Xp0,Xe0)
          )

       + Ab(Xps,eps)*F0^-3*pi16 * (
          + 3/16*Xss
          + 3/16*Xb(1)
          )

       + Ab(Xn1)*F0^-3*pi16 * (
          + 1/16*Xb(1)*RV(Xn1,Xn2,X11,X33)
          - 1/48*RV(Xn1,Xn2,X11,X33)*Xn1
          + 1/16*RV(Xn1,Xn2,X11,X33)*X13
          )

       + Ab(Xn1)*F0^-3*L0r * (
          + 4*R(Xn1,Xn2,X11,X33)*Xn1
          + 2/3*RV(Xn1,Xn2,X11,X33)*Xn1
          )

       + Ab(Xn1)*F0^-3*L1r * (
          - 8*Xn1
          )

       + Ab(Xn1)*F0^-3*L2r * (
          - 2*Xn1
          )

       + Ab(Xn1)*F0^-3*L3r * (
          + 4*R(Xn1,Xn2,X11,X33)*Xn1
          + 5/3*RV(Xn1,Xn2,X11,X33)*Xn1
          )

       + Ab(Xn1)*F0^-3*L4r * (
          + 4*Xn1
          + Xb(1)*RV(Xn1,Xn2,X11,X33)
          )

       + Ab(Xn1)*F0^-3*L5r * (
          - 4/3*R(Xn1,Xn2,X11,X33)*X13
          - 1/3*RV(Xn1,Xn2,X11,X33)*X13
          )

       + Ab(Xn1)^2*F0^-3 * (
          + 1/288*RV(Xn1,Xn2,X11,X33)^2
          )

       + Ab(Xn1)*Ab(Xst)*F0^-3 * (
          - 1/108*RV(Xn1,Xn2,X11,X33)*RV(Xn1,Xn2,Xss,Xtt)
          )

       + Ab(Xn1)*Bb(Xpp,Xpp,0)*F0^-3 * (
          - 1/18*R(Xpp,Xqq,Xn1,Xn2)*R(Xn1,Xn2,Xpp,Xpp)*Xpp
          - 1/108*R(Xpp,Xss,Xn1,Xn2)^2*R(Xn1,Xn2,Xss,Xss)*Xss
          + 1/18*R(Xn1,Xn2,Xpp,Xpp)*RC(Xpp)*Xpp
          + 1/144*RD(Xpp)*RV(Xn1,Xn2,X11,X33)
          )

       + Ab(Xn1)*Bb(Xpp,Xn1,0)*F0^-3 * (
          - 1/54*R(Xpp,Xss,Xn1,Xn2)*R(Xn1,Xn2,Xpp,Xss)*R(Xn1,Xn2,Xss,Xss)*Xss
          + 1/54*R(Xpp,Xss,Xn1,Xn2)*R(Xn1,Xn2,Xqq,Xss)*R(Xn1,Xn2,Xss,Xss)*Xss
          + 1/18*R(Xn1,Xn2,Xpp,Xpp)^2*Xpp
          - 1/18*R(Xn1,Xn2,Xpp,Xpp)*R(Xn1,Xn2,X11,X33)*Xpp
          )

       + Ab(Xn1)*Bb(Xpp,Xn2,0)*F0^-3 * (
          - 1/54*R(Xpp,Xss,Xn1,Xn2)*R(Xn1,Xn2,Xss,Xss)*R(Xn2,Xn1,Xpp,Xss)*Xss
          + 1/54*R(Xpp,Xss,Xn1,Xn2)*R(Xn1,Xn2,Xss,Xss)*R(Xn2,Xn1,Xqq,Xss)*Xss
          + 1/18*R(Xn1,Xn2,Xpp,Xpp)*R(Xn2,Xn1,Xpp,Xpp)*Xpp
          - 1/18*R(Xn1,Xn2,Xpp,Xpp)*R(Xn2,Xn1,X11,X33)*Xpp
          )

       + Ab(Xn1)*Bb(Xps,Xps,0)*F0^-3 * (
          - 1/12*R(Xn1,Xn2,Xpp,Xss)*Xps
          )

       + Ab(Xn1)*Bb(Xn1,Xn1,0)*F0^-3 * (
          - 1/108*R(Xn1,Xn2,Xss,Xss)^2*RV(Xn1,Xn2,X11,X33)*Xss
          )

       + Ab(Xn1)*Bb(Xn1,Xn2,0)*F0^-3 * (
          - 1/54*R(Xn1,Xn2,Xpp,Xss)*R(Xn1,Xn2,Xss,Xss)*R(Xn2,Xn1,Xpp,Xss)*Xss
          + 1/54*R(Xn1,Xn2,Xqq,Xss)*R(Xn1,Xn2,Xss,Xss)*R(Xn2,Xn1,Xpp,Xss)*Xss
          )

       + Ab(Xn1)*Bb(Xn2,Xn2,0)*F0^-3 * (
          - 1/108*R(Xn1,Xn2,Xss,Xss)*R(Xn2,Xn1,Xss,Xss)*RV(Xn2,Xn1,X11,X33)*
         Xss
          )

       + Ab(Xn1)*Bb(X11,X33,0)*F0^-3 * (
          - 1/18*R(Xqq,Xpp,Xn1,Xn2)*R(Xn1,Xn2,Xpp,Xpp)*Xpp
          + 1/54*R(Xn1,Xn2,Xss,Xss)*R(X11,Xss,Xn1,Xn2)*R(X33,Xss,Xn1,Xn2)*Xss
          )

       + Ab(Xn1)*Cb(Xpp,Xpp,Xpp,0)*F0^-3 * (
          + 1/18*R(Xn1,Xn2,Xpp,Xpp)*RD(Xpp)*Xpp
          )

       + Ab(Xn1,eps)*F0^-3*pi16 * (
          + 1/8*Xn1
          - 1/16*Xb(1)*RV(Xn1,Xn2,X11,X33)
          - 1/8*R(Xn1,Xn2,X11,X33)*Xn1
          - 1/16*RV(Xn1,Xn2,X11,X33)*Xn1
          )

       + Ab(Xp0)*Ab(Xe0)*F0^-3 * (
          + 1/144*RV(Xp0,Xe0,X11,X33)*RV(Xe0,Xp0,X11,X33)
          )

       + Ab(X11)*Ab(X33)*F0^-3 * (
          - 1/72*R(Xpp,Xqq,Xp0,Xe0)*RC(Xqq)
          + 1/36*R(X11,X33,Xp0,Xe0)*R(X33,X11,Xp0,Xe0)
          + 1/144*RC(X11)*RC(X33)
          )

       + Ab(X13)*F0^-3*L1r * (
          - 4*X13
          )

       + Ab(X13)*F0^-3*L2r * (
          - 10*X13
          )

       + Ab(X13)^2*F0^-3 * (
          + 1/8
          )

       + Ab(X13)*Bb(X11,X33,0,kk)*F0^-3 * (
          - 1/2
          )

       + Ab(X13,eps)*F0^-3*pi16 * (
          + 1/4*X13
          )

       + Ab(X1s)*Ab(X3s)*F0^-3 * (
          + 1/16
          )

       + Ab(Xst)*F0^-3*L1r * (
          - 16*Xst
          )

       + Ab(Xst)*F0^-3*L2r * (
          - 4*Xst
          )

       + Ab(Xst)*F0^-3*L4r * (
          + 8*Xst
          )

       + Ab(Xst)*Bb(Xpp,Xpp,0)*F0^-3 * (
          + 1/18*R(Xpp,Xss,Xp0,Xe0)*R(Xpp,Xtt,Xp0,Xe0)*Xst
          )

       + Ab(Xst)*Bb(Xpp,Xn1,0)*F0^-3 * (
          + 1/54*RW(Xpp,Xn1,Xn2,Xpp,Xss,Xtt)
          - 1/54*RW(Xpp,Xn1,Xn2,Xqq,Xss,Xtt)
          )

       + Ab(Xst)*Bb(Xpp,Xn1,0,kk)*F0^-3 * (
          - 1/54*RU(Xpp,Xn1,Xn2,Xpp,Xss,Xtt)
          + 1/54*RU(Xpp,Xn1,Xn2,Xqq,Xss,Xtt)
          )

       + Ab(Xst)*Bb(Xn1,Xn1,0)*F0^-3 * (
          + 1/18*R(Xn1,Xn2,Xss,Xtt)*RV(Xn1,Xn2,X11,X33)*Xst
          )

       + Ab(Xst)*Bb(Xp0,Xe0,0)*F0^-3 * (
          + 1/54*RW(Xp0,Xe0,Xpp,Xe0,Xp0,Xpp,Xss,Xtt)
          - 1/54*RW(Xp0,Xe0,Xpp,Xe0,Xp0,Xqq,Xss,Xtt)
          )

       + Ab(Xst)*Bb(Xp0,Xe0,0,kk)*F0^-3 * (
          - 1/54*RU(Xp0,Xe0,Xpp,Xe0,Xp0,Xpp,Xss,Xtt)
          + 1/54*RU(Xp0,Xe0,Xpp,Xe0,Xp0,Xqq,Xss,Xtt)
          )

       + Ab(Xst)*Bb(X11,X33,0)*F0^-3 * (
          - 1/54*RW(X11,X33,Xss,Xtt)
          )

       + Ab(Xst)*Bb(X11,X33,0,kk)*F0^-3 * (
          + 1/54*RU(X11,X33,Xss,Xtt)
          )

       + Ab(Xst,eps)*F0^-3*pi16 * (
          + 1/4*Xst
          )

       + Bb(Xpp,Xpp,0)*F0^-3*pi16 * (
          + 1/16*Xb(1)*RD(Xpp)
          + 1/96*RD(Xpp)*Xpp
          + 1/32*RD(Xpp)*Xqq
          )

       + Bb(Xpp,Xpp,0)*F0^-3*L0r * (
          + 2/3*RD(Xpp)*Xpp
          )

       + Bb(Xpp,Xpp,0)*F0^-3*L3r * (
          + 5/3*RD(Xpp)*Xpp
          )

       + Bb(Xpp,Xpp,0)*F0^-3*L4r * (
          - 4*Xb(1)*R(Xpp,Xqq,Xp0,Xe0)*Xpp
          + 2*Xb(1)*RC(Xpp)*Xpp
          + 3*Xb(1)*RD(Xpp)
          )

       + Bb(Xpp,Xpp,0)*F0^-3*L5r * (
          - 4/3*R(Xpp,Xqq,Xp0,Xe0)*X11*X33
          + 2/3*RC(Xpp)*Xpp^2
          - 1/3*RD(Xpp)*X13
          )

       + Bb(Xpp,Xpp,0)*F0^-3*L6r * (
          + 8*Xb(1)*R(Xpp,Xqq,Xp0,Xe0)*Xpp
          - 4*Xb(1)*RC(Xpp)*Xpp
          - 4*Xb(1)*RD(Xpp)
          )

       + Bb(Xpp,Xpp,0)*F0^-3*L7r * (
          + 4*RD(Xpp)^2
          )

       + Bb(Xpp,Xpp,0)*F0^-3*L8r * (
          + 8/3*R(Xpp,Xqq,Xp0,Xe0)*X11*X33
          - 4/3*RC(Xpp)*Xpp^2
          + 4/3*RD(Xpp)^2
          )

       + Bb(Xpp,Xpp,0)^2*F0^-3 * (
          - 1/18*R(Xpp,Xqq,Xp0,Xe0)*RD(Xpp)*Xpp
          + 1/18*RC(Xpp)*RD(Xpp)*Xpp
          + 1/288*RD(Xpp)^2
          )

       + Bb(Xpp,Xpp,0)*Bb(Xpp,Xn1,0)*F0^-3 * (
          + 1/18*RS(Xqq,Xn1,Xpp)*RD(Xpp)*RV(Xn1,Xn2,X11,X33)*Xpp
          )

       + Bb(Xpp,Xpp,0)*Bb(X11,X33,0)*F0^-3 * (
          - 1/18*R(Xqq,Xpp,Xp0,Xe0)*RD(Xpp)*Xpp
          )

       + Bb(Xpp,Xpp,0)*Cb(Xpp,Xpp,Xpp,0)*F0^-3 * (
          + 1/18*RD(Xpp)^2*Xpp
          )

       + Bb(Xpp,Xpp,0,eps)*F0^-3*pi16 * (
          - 1/16*Xb(1)*RD(Xpp)
          - 1/16*RD(Xpp)*Xpp
          )

       + Bb(Xpp,Xn1,0)*F0^-3*L7r * (
          + 8*RS(Xqq,Xpp,Xn1)*RD(Xpp)*RD(Xn1,X44,X55,X66,Xn2,Xpp)
          )

       + Bb(Xpp,Xn1,0)*F0^-3*L8r * (
          + 8/3*RS(Xqq,Xpp,Xn1)*RD(Xpp)*RD(Xn1,X44,X55,X66,Xn2,Xpp)
          )

       + Bb(Xps,Xps,0)*F0^-3*L4r * (
          - 6*Xb(1)*Xps
          )

       + Bb(Xps,Xps,0)*F0^-3*L5r * (
          - 2*Xps^2
          )

       + Bb(Xps,Xps,0)*F0^-3*L6r * (
          + 12*Xb(1)*Xps
          )

       + Bb(Xps,Xps,0)*F0^-3*L8r * (
          + 4*Xps^2
          )

       + Bb(Xn1,Xn1,0)*F0^-3*L4r * (
          + 2*Xb(1)*RV(Xn1,Xn2,X11,X33)*Xn1
          )

       + Bb(Xn1,Xn1,0)*F0^-3*L5r * (
          + 2/3*RV(Xn1,Xn2,X11,X33)*Xn1^2
          )

       + Bb(Xn1,Xn1,0)*F0^-3*L6r * (
          - 4*Xb(1)*RV(Xn1,Xn2,X11,X33)*Xn1
          )

       + Bb(Xn1,Xn1,0)*F0^-3*L7r * (
          + 4*RS(X33,X11,X11,Xn1,Xn1)*RD(Xn1,X44,X55,X66,Xn2,X11)^2
          )

       + Bb(Xn1,Xn1,0)*F0^-3*L8r * (
          + 4/3*RS(X33,X11,X11,Xn1,Xn1)*RD(Xn1,X44,X55,X66,Xn2,X11)^2
          - 4/3*RV(Xn1,Xn2,X11,X33)*Xn1^2
          )

       + Bb(Xp0,Xe0,0)*F0^-3*L7r * (
          + 8*RS(X33,X11,X11,Xp0,Xe0)*RD(Xp0,X44,X55,X66,Xe0,X11)*RD(Xe0,X44,
         X55,X66,Xp0,X11)
          )

       + Bb(Xp0,Xe0,0)*F0^-3*L8r * (
          + 8/3*RS(X33,X11,X11,Xp0,Xe0)*RD(Xp0,X44,X55,X66,Xe0,X11)*RD(Xe0,X44
         ,X55,X66,Xp0,X11)
          )

       + Bb(X11,X11,0)*Bb(X33,X33,0)*F0^-3 * (
          + 1/144*RD(X11)*RD(X33)
          )

       + Bb(X11,X33,0)*F0^-3*L7r * (
          - 8*RD(X11)*RD(X33)
          )

       + Bb(X11,X33,0)*F0^-3*L8r * (
          - 8/3*RD(X11)*RD(X33)
          )

       + Cb(Xpp,Xpp,Xpp,0)*F0^-3*L4r * (
          + 4*Xb(1)*RD(Xpp)*Xpp
          )

       + Cb(Xpp,Xpp,Xpp,0)*F0^-3*L5r * (
          + 4/3*RD(Xpp)*Xpp^2
          )

       + Cb(Xpp,Xpp,Xpp,0)*F0^-3*L6r * (
          - 8*Xb(1)*RD(Xpp)*Xpp
          )

       + Cb(Xpp,Xpp,Xpp,0)*F0^-3*L8r * (
          - 8/3*RD(Xpp)*Xpp^2
          )

       + Hbb(1,Xpp,Xpp,X13,X13)*F0^-3 * (
          + 1/8*Xpp
          - 1/16*X13
          - 1/36*R(Xpp,Xqq,Xp0,Xe0)^2*X13
          + 1/36*R(Xpp,Xqq,Xp0,Xe0)*RC(Xpp)*X13
          - 1/144*RC(Xpp)^2*X13
          )

       + Hbb(1,Xpp,X1s,X3s,X13)*F0^-3 * (
          - 1/12*R(Xpp,Xqq,Xp0,Xe0)*Xqs
          + 1/24*R(Xpp,Xqq,Xp0,Xe0)*X13
          - 1/16*R(Xpp,Xss,Xp0,Xe0)*Xpp
          + 1/48*R(Xpp,Xss,Xp0,Xe0)*Xqq
          + 1/24*RC(Xpp)*Xps
          )

       + Hbb(1,Xps,Xqt,Xst,X13)*F0^-3 * (
          - 1/8*Xst
          )

       + Hbb(1,Xn1,Xpp,X13,X13)*F0^-3 * (
          + 1/36*R(Xpp,Xqq,Xn1,Xn2)*RV(Xn1,Xn2,X11,X33)*X13
          - 1/72*RC(Xpp)*RV(Xn1,Xn2,X11,X33)*X13
          )

       + Hbb(1,Xn1,Xn1,X13,X13)*F0^-3 * (
          - 1/144*RV(Xn1,Xn2,X11,X33)^2*X13
          )

       + Hbb(1,Xn1,X1s,X3s,X13)*F0^-3 * (
          - 1/48*R(Xn1,Xn2,Xpp,Xss)*Xpp
          + 1/48*R(Xn1,Xn2,Xpp,Xss)*Xqq
          + 1/48*RV(Xn1,Xn2,Xpp,Xss)*Xn1
          + 1/48*RV(Xn1,Xn2,X11,X33)*Xss
          )

       + Hbb(1,Xp0,Xe0,X13,X13)*F0^-3 * (
          - 1/72*RV(Xp0,Xe0,X11,X33)*RV(Xe0,Xp0,X11,X33)*X13
          )

       + Hbb(1,X11,X13,X33,X13)*F0^-3 * (
          + 1/36*R(Xpp,Xqq,Xp0,Xe0)*RC(Xqq)*X13
          - 1/18*R(X11,X33,Xp0,Xe0)*R(X33,X11,Xp0,Xe0)*X13
          - 1/72*RC(X11)*RC(X33)*X13
          )

       + Hbb(1,X13,X13,X13,X13)*F0^-3 * (
          - 1/8*X13
          )

       + Hbb(2,Xpp,Xpp,X13,X13)*F0^-3 * (
          + 1/36*R(Xpp,Xqq,Xp0,Xe0)*RD(Xpp)*X13
          - 1/72*RC(Xpp)*RD(Xpp)*X13
          )

       + Hbb(2,Xpp,Xn1,X13,X13)*F0^-3 * (
          - 1/72*RD(Xpp)*RV(Xn1,Xn2,X11,X33)*X13
          )

       + Hbb(2,Xpp,X13,Xqq,X13)*F0^-3 * (
          + 1/36*R(Xqq,Xpp,Xp0,Xe0)*RD(Xpp)*X13
          - 1/72*RC(Xqq)*RD(Xpp)*X13
          )

       + Hbb(2,Xpp,X1s,X3s,X13)*F0^-3 * (
          + 1/24*RD(Xpp)*Xps
          )

       + Hbb(5,Xpp,Xpp,X13,X13)*F0^-3 * (
          - 1/144*RD(Xpp)^2*X13
          )

       + Hbb(5,X11,X33,X13,X13)*F0^-3 * (
          - 1/72*RD(X11)*RD(X33)*X13
          )

       + dHbb(1,Xpp,Xpp,X13,X13)*F0^-3 * (
          - 1/8*Xpp*X13
          - 3/16*X13^2
          - 1/36*R(Xpp,Xqq,Xp0,Xe0)^2*X13^2
          + 1/12*R(Xpp,Xqq,Xp0,Xe0)*RC(Xpp)*X13^2
          - 1/48*RC(Xpp)^2*X13^2
          )

       + dHbb(1,Xpp,X1s,X3s,X13)*F0^-3 * (
          - 5/24*R(Xpp,Xqq,Xp0,Xe0)*Xqq*X13
          + 1/12*R(Xpp,Xqq,Xp0,Xe0)*Xps*X13
          + 1/16*R(Xpp,Xss,Xp0,Xe0)*Xqq*X13
          + 7/48*R(Xpp,Xss,Xp0,Xe0)*X13*Xss
          - 1/24*RC(Xpp)*Xps*X13
          )

       + dHbb(1,Xps,Xqt,Xst,X13)*F0^-3 * (
          + 1/8*X13*Xst
          )

       + dHbb(1,Xn1,Xpp,X13,X13)*F0^-3 * (
          + 1/9*R(Xpp,Xqq,Xn1,Xn2)*R(Xn1,Xn2,X11,X33)*X13^2
          - 1/36*R(Xpp,Xqq,Xn1,Xn2)*RV(Xn1,Xn2,X11,X33)*X13^2
          + 1/18*R(Xn1,Xn2,Xpp,Xpp)*RC(Xpp)*X13^2
          + 1/72*RC(Xpp)*RV(Xn1,Xn2,X11,X33)*X13^2
          )

       + dHbb(1,Xn1,Xn1,X13,X13)*F0^-3 * (
          + 1/9*R(Xn1,Xn2,X11,X33)^2*X13^2
          + 1/9*R(Xn1,Xn2,X11,X33)*RV(Xn1,Xn2,X11,X33)*X13^2
          + 5/144*RV(Xn1,Xn2,X11,X33)^2*X13^2
          )

       + dHbb(1,Xn1,X1s,X3s,X13)*F0^-3 * (
          - 1/16*R(Xn1,Xn2,Xpp,Xss)*Xpp*X13
          - 5/48*R(Xn1,Xn2,Xpp,Xss)*Xqq*X13
          + 1/6*R(Xn1,Xn2,X11,X33)*X13^2
          - 1/48*RV(Xn1,Xn2,Xpp,Xss)*Xn1*X13
          - 1/48*RV(Xn1,Xn2,X11,X33)*X13*Xss
          )

       + dHbb(1,Xp0,Xe0,X13,X13)*F0^-3 * (
          + 1/18*R(Xp0,Xe0,Xpp,Xpp)*R(Xe0,Xp0,Xpp,Xpp)*X13^2
          + 1/9*R(Xp0,Xe0,X11,X33)*R(Xe0,Xp0,X11,X33)*X13^2
          + 1/72*RV(Xp0,Xe0,X11,X33)*RV(Xe0,Xp0,X11,X33)*X13^2
          )

       + dHbb(1,X11,X13,X33,X13)*F0^-3 * (
          - 1/36*R(Xpp,Xqq,Xp0,Xe0)*RC(Xqq)*X13^2
          + 1/6*R(X11,X33,Xp0,Xe0)*R(X33,X11,Xp0,Xe0)*X13^2
          + 1/72*RC(X11)*RC(X33)*X13^2
          )

       + dHbb(1,X13,X13,X13,X13)*F0^-3 * (
          + 1/8*X13^2
          )

       + dHbb(2,Xpp,Xpp,X13,X13)*F0^-3 * (
          - 1/36*R(Xpp,Xqq,Xp0,Xe0)*RD(Xpp)*X13^2
          + 5/72*RC(Xpp)*RD(Xpp)*X13^2
          )

       + dHbb(2,Xpp,Xn1,X13,X13)*F0^-3 * (
          + 1/18*R(Xn1,Xn2,Xpp,Xpp)*RD(Xpp)*X13^2
          + 1/72*RD(Xpp)*RV(Xn1,Xn2,X11,X33)*X13^2
          )

       + dHbb(2,Xpp,X13,Xqq,X13)*F0^-3 * (
          - 1/36*R(Xqq,Xpp,Xp0,Xe0)*RD(Xpp)*X13^2
          + 1/72*RC(Xqq)*RD(Xpp)*X13^2
          )

       + dHbb(2,Xpp,X1s,X3s,X13)*F0^-3 * (
          - 1/24*RD(Xpp)*Xps*X13
          )

       + dHbb(5,Xpp,Xpp,X13,X13)*F0^-3 * (
          + 5/144*RD(Xpp)^2*X13^2
          )

       + dHbb(5,X11,X33,X13,X13)*F0^-3 * (
          + 1/72*RD(X11)*RD(X33)*X13^2
          )

       + dH1bb(1,Xpp,Xpp,X13,X13)*F0^-3 * (
          + X13^2
          + 2/9*R(Xpp,Xqq,Xp0,Xe0)^2*X13^2
          - 2/9*R(Xpp,Xqq,Xp0,Xe0)*RC(Xpp)*X13^2
          + 1/9*RC(Xpp)^2*X13^2
          )

       + dH1bb(1,Xpp,X1s,X3s,X13)*F0^-3 * (
          + 1/3*R(Xpp,Xqq,Xp0,Xe0)*RS(Xss,Xqq,Xpp)*X13^2
          )

       + dH1bb(1,Xps,Xqs,Xpp,X13)*F0^-3 * (
          - 1/3*R(Xpp,Xss,Xp0,Xe0)*X13^2
          )

       + dH1bb(1,Xps,Xqs,Xn1,X13)*F0^-3 * (
          - 1/3*R(Xn1,Xn2,X11,X33)*RS(Xss,Xpp,Xn1)*X13^2
          )

       + dH1bb(1,X13,Xpp,Xn1,X13)*F0^-3 * (
          + 1/9*R(Xpp,Xqq,Xn1,Xn2)*RV(Xn1,Xn2,X11,X33)*X13^2
          - 1/9*R(Xn1,Xn2,Xpp,Xpp)*RS(Xqq,Xpp,Xn1)*RC(Xpp)*X13^2
          )

       + dH1bb(1,X13,Xn1,Xn1,X13)*F0^-3 * (
          - 1/9*R(Xn1,Xn2,X11,X33)*RV(Xn1,Xn2,X11,X33)*X13^2
          - 1/18*RV(Xn1,Xn2,X11,X33)^2*X13^2
          )

       + dH1bb(1,X13,Xp0,Xe0,X13)*F0^-3 * (
          - 1/9*R(Xp0,Xe0,Xpp,Xpp)*RS(Xqq,Xe0,Xpp)*RV(Xe0,Xp0,X11,X33)*X13^2
          + 1/9*R(Xp0,Xe0,X11,X33)*RV(Xe0,Xp0,X11,X33)*X13^2
          )

       + dH1bb(1,X13,X11,X33,X13)*F0^-3 * (
          + 1/9*R(Xpp,Xqq,Xp0,Xe0)*RC(Xqq)*X13^2
          - 2/9*R(X11,X33,Xp0,Xe0)*R(X33,X11,Xp0,Xe0)*X13^2
          )

       + dH1bb(3,X13,Xpp,Xpp,X13)*F0^-3 * (
          + 1/9*R(Xpp,Xqq,Xp0,Xe0)*RD(Xpp)*X13^2
          - 1/9*RC(Xpp)*RD(Xpp)*X13^2
          )

       + dH1bb(3,X13,Xpp,Xqq,X13)*F0^-3 * (
          + 1/9*R(Xqq,Xpp,Xp0,Xe0)*RD(Xpp)*X13^2
          )

       + dH1bb(3,X13,Xpp,Xn1,X13)*F0^-3 * (
          + 1/9*R(Xn1,Xn2,X11,X33)*RS(Xpp,Xqq,Xn1)*RD(Xpp)*X13^2
          )

       + dH1bb(7,X13,Xpp,Xpp,X13)*F0^-3 * (
          - 1/18*RD(Xpp)^2*X13^2
          )

       + dH21bb(1,Xpp,Xpp,X13,X13)*F0^-3 * (
          - 3/8*X13^2
          )

       + dH21bb(1,Xpp,X1s,X3s,X13)*F0^-3 * (
          - 1/8*R(Xpp,Xqq,Xp0,Xe0)*RS(Xss,Xqq,Xpp)*X13^2
          )

       + dH21bb(1,Xps,Xqs,Xpp,X13)*F0^-3 * (
          + 1/8*R(Xpp,Xqq,Xp0,Xe0)*X13^2
          + 1/8*R(Xpp,Xss,Xp0,Xe0)*X13^2
          - 1/8*RC(Xpp)*X13^2
          )

       + dH21bb(1,Xps,Xqs,Xqq,X13)*F0^-3 * (
          + 1/8*R(Xqq,Xpp,Xp0,Xe0)*RS(Xss,Xpp,Xqq)*X13^2
          )

       + dH21bb(1,Xps,Xqs,Xn1,X13)*F0^-3 * (
          + 1/8*R(Xn1,Xn2,X11,X33)*RS(Xpp,Xqq,Xn1)*RS(Xss,Xpp,Xn1)*X13^2
          )

       + dH21bb(1,Xn1,X1s,X3s,X13)*F0^-3 * (
          - 1/8*R(Xn1,Xn2,X11,X33)*RS(Xss,X11,Xn1)*RS(Xss,X33,Xn1)*X13^2
          )

       + dH21bb(1,X13,Xpp,Xpp,X13)*F0^-3 * (
          + 3/16*X13^2
          + 1/12*R(Xpp,Xqq,Xp0,Xe0)^2*X13^2
          - 1/12*R(Xpp,Xqq,Xp0,Xe0)*RC(Xpp)*X13^2
          + 1/48*RC(Xpp)^2*X13^2
          )

       + dH21bb(1,X13,Xpp,Xn1,X13)*F0^-3 * (
          - 1/12*R(Xpp,Xqq,Xn1,Xn2)*RV(Xn1,Xn2,X11,X33)*X13^2
          + 1/24*RC(Xpp)*RV(Xn1,Xn2,X11,X33)*X13^2
          )

       + dH21bb(1,X13,Xn1,Xn1,X13)*F0^-3 * (
          + 1/48*RV(Xn1,Xn2,X11,X33)^2*X13^2
          )

       + dH21bb(1,X13,Xp0,Xe0,X13)*F0^-3 * (
          + 1/24*RV(Xp0,Xe0,X11,X33)*RV(Xe0,Xp0,X11,X33)*X13^2
          )

       + dH21bb(1,X13,X11,X33,X13)*F0^-3 * (
          - 1/12*R(Xpp,Xqq,Xp0,Xe0)*RC(Xqq)*X13^2
          + 1/6*R(X11,X33,Xp0,Xe0)*R(X33,X11,Xp0,Xe0)*X13^2
          + 1/24*RC(X11)*RC(X33)*X13^2
          )

       + dH21bb(1,X13,X13,X13,X13)*F0^-3 * (
          + 3/8*X13^2
          )

       + dH21bb(1,Xst,Xps,Xqt,X13)*F0^-3 * (
          + 3/8*X13^2
          )

       + dH21bb(3,Xps,Xpp,Xqs,X13)*F0^-3 * (
          - 1/8*RD(Xpp)*X13^2
          )

       + dH21bb(3,X13,Xpp,Xpp,X13)*F0^-3 * (
          - 1/12*R(Xpp,Xqq,Xp0,Xe0)*RD(Xpp)*X13^2
          + 1/24*RC(Xpp)*RD(Xpp)*X13^2
          )

       + dH21bb(3,X13,Xpp,Xqq,X13)*F0^-3 * (
          - 1/12*R(Xqq,Xpp,Xp0,Xe0)*RD(Xpp)*X13^2
          + 1/24*RC(Xqq)*RD(Xpp)*X13^2
          )

       + dH21bb(3,X13,Xpp,Xn1,X13)*F0^-3 * (
          + 1/24*RD(Xpp)*RV(Xn1,Xn2,X11,X33)*X13^2
          )

       + dH21bb(7,X13,Xpp,Xpp,X13)*F0^-3 * (
          + 1/48*RD(Xpp)^2*X13^2
          )

       + dH21bb(7,X13,X11,X33,X13)*F0^-3 * (
          + 1/24*RD(X11)*RD(X33)*X13^2
          );


