sigmaKerr0 = s1x+s2x
sigmaKerr1 = s1y+s2y
sigmaKerr2 = s1z+s2z
invm1m2 = 1/(m1*m2)
m2overm1 = m2*m2*invm1m2
m1overm2 = m1*m1*invm1m2
sigmaStar0 = (m2overm1)*s1x+(m1overm2)*s2x
sigmaStar1 = (m2overm1)*s1y+(m1overm2)*s2y
sigmaStar2 = (m2overm1)*s1z+(m1overm2)*s2z
s1dots1 = s1x*s1x+s1y*s1y+s1z*s1z
s2dots2 = s2x*s2x+s2y*s2y+s2z*s2z
r2 = x*x+y*y+z*z
r = sp.sqrt(r2)
u = 1/r
u2 = u*u
u3 = u2*u
u4 = u2*u2
u5 = u4*u
etau3 = eta*u3
etau4 = eta*u4
nx = x*u
ny = y*u
nz = z*u
sKerrUSCOREx = sigmaKerr0
sKerrUSCOREy = sigmaKerr1
sKerrUSCOREz = sigmaKerr2
sStarUSCOREx = sigmaStar0
sStarUSCOREy = sigmaStar1
sStarUSCOREz = sigmaStar2
a2 = sKerrUSCOREx*sKerrUSCOREx+sKerrUSCOREy*sKerrUSCOREy+sKerrUSCOREz*sKerrUSCOREz
a4 = a2*a2
a = sp.sqrt(a2)
inva = 1/a
m1PlusetaKK = -1+eta*KK
m1PlusetaKKsq = m1PlusetaKK*m1PlusetaKK
invm1PlusetaKK = 1/m1PlusetaKK
k1sq = k1*k1
k1cu = k1sq*k1
k1ft = k1cu*k1
k2 = 0.5*k1*(k1-4.*m1PlusetaKK)-a2*m1PlusetaKKsq*k0
k2sq = k2*k2
k3 = -k1cu/3.+k1*k2+k1sq*m1PlusetaKK-2.*(k2-m1PlusetaKK)*m1PlusetaKK-a2*k1*m1PlusetaKKsq
k4 = 1./12.*(6*a2*(k1sq-2*k2)*m1PlusetaKKsq+3*k1ft-8*m1PlusetaKK*k1cu-12*k2*k1sq+12*(2*m1PlusetaKK*k2+k3)*k1+12*(94./3.-41./32.*sp.pi*sp.pi)*m1PlusetaKKsq+6*(k2*k2-4*k3*m1PlusetaKK))
k5 = m1PlusetaKKsq*(-4237./60.+128./5.*EMgamma+2275./512.*sp.pi*sp.pi-a2*(k1cu-3.*k1*k2+3.*k3)/3.-(k1ft*k1-5.*k1cu*k2+5.*k1*k2sq+5.*k1sq*k3-5.*k2*k3-5.*k1*k4)/(5.*m1PlusetaKKsq)+(k1ft-4.*k1sq*k2+2.*k2sq+4.*k1*k3-4.*k4)/(2*m1PlusetaKK)+(256./5.)*sp.log(2))
k5l = (64./5.)*m1PlusetaKKsq
e3USCOREx = sKerrUSCOREx*inva
e3USCOREy = sKerrUSCOREy*inva
e3USCOREz = sKerrUSCOREz*inva
costheta = e3USCOREx*nx+e3USCOREy*ny+e3USCOREz*nz
xi2 = 1-costheta*costheta
xiUSCOREx = -e3USCOREz*ny+e3USCOREy*nz
xiUSCOREy = e3USCOREz*nx-e3USCOREx*nz
xiUSCOREz = -e3USCOREy*nx+e3USCOREx*ny
vx = -nz*xiUSCOREy+ny*xiUSCOREz
vy = nz*xiUSCOREx-nx*xiUSCOREz
vz = -ny*xiUSCOREx+nx*xiUSCOREy
w2 = r2+a2
rho2 = r2+a2*costheta*costheta
bulk = invm1PlusetaKK*(invm1PlusetaKK+2*u)+a2*u2
logu = sp.log(u)
logarg = k1*u+k2*u2+k3*u3+k4*u4+k5*u5+k5l*u5*logu
onepluslogarg = (1+logarg)
invonepluslogarg = 1/onepluslogarg
logTerms = 1+eta*k0+eta*sp.log(sp.Abs(onepluslogarg))
deltaU = sp.Abs(bulk*logTerms)
deltaT = r2*deltaU
deltaUUSCOREupt7 = k5+k5l*logu
deltaUUSCOREupt6 = 4*k4+5*deltaUUSCOREupt7*u
deltaUUSCOREupt5 = 3*k3+u*deltaUUSCOREupt6
deltaUUSCOREupt4 = 2*k2+u*deltaUUSCOREupt5
deltaUUSCOREupt3 = k1+u*deltaUUSCOREupt4
deltaUUSCOREupt2 = invm1PlusetaKK+a2*u
deltaUUSCOREupt1 = bulk*eta*deltaUUSCOREupt3
deltaUUSCOREu = 2*deltaUUSCOREupt2*logTerms+deltaUUSCOREupt1*invonepluslogarg
deltaTUSCOREr = 2*r*deltaU-deltaUUSCOREu
Lamb = sp.Abs(w2*w2-a2*deltaT*xi2)
rho2xi2Lamb = rho2*xi2*Lamb
invrho2xi2Lamb = 1/rho2xi2Lamb
invrho2 = 1/rho2
invxi2 = 1/xi2
invLamb = 1/Lamb
invLambsq = invLamb*invLamb
rho2invLamb = rho2*invLamb
expnu = sp.sqrt(deltaT*rho2invLamb)
expMU = sp.sqrt(rho2)
expMUexpnu = expMU*expnu
expMUsq = expMU*expMU
expnusq = expnu*expnu
expMUsqexpnusq = expMUsq*expnusq
invexpnuexpMU = 1/expMUexpnu
invexpMU = expnu*invexpnuexpMU
invexpMUsq = invexpMU*invexpMU
expnuinvexpMU2 = expnu*invexpMUsq
invexpMUcubinvexpnu = invexpMUsq*invexpnuexpMU
DD = 1+sp.log(1+6*eta*u2+2*(26-3*eta)*etau3)
deltaR = deltaT*DD
qq = 2*eta*(4-3*eta)
b3 = 0
bb3 = 0
ww = 2*a*r+b3*eta*a2*a*u+bb3*eta*a*u
B = sp.sqrt(deltaT)
sqrtdeltaT = B
sqrtdeltaR = sp.sqrt(deltaR)
deltaTsqrtdeltaR = deltaT*sqrtdeltaR
sqrtdeltaTdeltaTsqrtdeltaR = sqrtdeltaT*deltaTsqrtdeltaR
invdeltaTsqrtdeltaTsqrtdeltaR = 1./sqrtdeltaTdeltaTsqrtdeltaR
invdeltaT = sqrtdeltaT*(sqrtdeltaR*invdeltaTsqrtdeltaTsqrtdeltaR)
invsqrtdeltaT = deltaTsqrtdeltaR*invdeltaTsqrtdeltaTsqrtdeltaR
invsqrtdeltaR = deltaT*sqrtdeltaT*invdeltaTsqrtdeltaTsqrtdeltaR
w = ww*invLamb
LambUSCOREr = 4*r*w2-a2*deltaTUSCOREr*xi2
wwUSCOREr = 2*a-(a2*a*b3*eta)*u2-bb3*eta*a*u2
BR = (-deltaT*invsqrtdeltaR+deltaTUSCOREr*sp.Rational(1,2))*invsqrtdeltaT
wr = (-LambUSCOREr*ww+Lamb*wwUSCOREr)*(invLambsq)
nurpt2 = w2*(-4.*r*deltaT+w2*deltaTUSCOREr)
nurpt1 = nurpt2*invdeltaT
nur = r*invrho2+sp.Rational(1,2)*invLamb*nurpt1
mur = r*invrho2-invsqrtdeltaR
a2costheta = a2*costheta
wcospt2 = deltaT*ww
wcospt1 = invLambsq*wcospt2
wcos = -2*(a2costheta)*wcospt1
nucospt3 = invrho2*invLamb
nucospt2 = w2*nucospt3
nucospt1 = a2costheta*nucospt2
nucos = (w2-deltaT)*nucospt1
mucos = a2costheta*invrho2
etaover12r = eta*sp.Rational(1,12)*u
csi = sp.sqrt(sp.Abs(deltaT*deltaR))/w2
csi1 = 1+(1-sp.Abs(1-tortoise))*(csi-1)
csi2 = 1+(sp.Rational(1,2)-0.5*sp.sign(1.5-tortoise))*(csi-1)
prT = (px*nx+py*ny+pz*nz)*csi2
prTtimesoneminuscsi1inv = prT*(1-1/csi1)
tmppx = px-nx*prTtimesoneminuscsi1inv
tmppy = py-ny*prTtimesoneminuscsi1inv
tmppz = pz-nz*prTtimesoneminuscsi1inv
pxir = (tmppx*xiUSCOREx+tmppy*xiUSCOREy+tmppz*xiUSCOREz)*r
pvr = (tmppx*vx+tmppy*vy+tmppz*vz)*r
pvrsq = pvr*pvr
pn = tmppx*nx+tmppy*ny+tmppz*nz
pnsq = pn*pn
pr = pn
prsq = pr*pr
pf = pxir
pxirsq = pxir*pxir
ptheta2 = pvrsq*invxi2
prT4 = prT*prT*prT*prT
Hnspt7 = deltaR*invrho2
Hnspt6 = rho2invLamb*invxi2
Hnspt5 = qq*u2
Hnspt4 = (1+prT4*Hnspt5+ptheta2*invrho2+pf*pf*Hnspt6+prsq*Hnspt7)
Hnspt3 = deltaT*Hnspt4
Hnspt2 = rho2*Hnspt3
Hnspt1 = pf*ww
Hns = sp.sqrt(Hnspt2*invLamb)+invLamb*Hnspt1
Qpt3 = deltaR*invrho2
Qpt2 = rho2invLamb*invxi2
Qpt1 = invrho2*invxi2
Q = 1+pvrsq*Qpt1+pxirsq*Qpt2+pnsq*Qpt3
pn2 = prsq*deltaR*invrho2
pp = Q-1
sKerrmultfact = (-8-3*r*(12*pn2-pp))
sStarmultfact = (14+(-30*pn2+4*pp)*r)
deltaSigmaStarUSCOREx1 = etaover12r*(sKerrmultfact*sKerrUSCOREx+sStarmultfact*sStarUSCOREx)
deltaSigmaStarUSCOREy1 = etaover12r*(sKerrmultfact*sKerrUSCOREy+sStarmultfact*sStarUSCOREy)
deltaSigmaStarUSCOREz1 = etaover12r*(sKerrmultfact*sKerrUSCOREz+sStarmultfact*sStarUSCOREz)
pn2pp = pn2*pp
pp2 = pp*pp
pn2u2 = pn2*u2
ppu2 = pp*u2
pn2ppu2 = pn2pp*u2
sMultiplier1pt6 = -360*pn2*pn2+126*pn2pp+3*pp2
sMultiplier1pt5 = -96*pn2pp+23*pp2
sMultiplier1pt4 = -120*pp+324*pn2+sMultiplier1pt6*r
sMultiplier1pt3 = 206*pp-282*pn2+sMultiplier1pt5*r
sMultiplier1pt2 = 54+sMultiplier1pt4*r
sMultiplier1pt1 = -706+sMultiplier1pt3*r+sMultiplier1pt2*eta
sMultiplier1 = sMultiplier1pt1*eta*u2*sp.Rational(-1,72)
sMultiplier2pt6 = sp.Rational(45,8)*pn2*pn2u2-sp.Rational(13,8)*pn2ppu2
sMultiplier2pt5 = pn2ppu2/4-sp.Rational(5,16)*pp2*u2
sMultiplier2pt4 = sp.Rational(-49,8)*pn2u2+sp.Rational(17,12)*ppu2+sMultiplier2pt6*r
sMultiplier2pt3 = sp.Rational(-2,3)*pn2u2-sp.Rational(109,36)*ppu2+sMultiplier2pt5*r
sMultiplier2pt2 = sp.Rational(-7,3)*u2+sMultiplier2pt4*r
sMultiplier2pt1 = sp.Rational(-56,9)*u2+sMultiplier2pt3*r+sMultiplier2pt2*eta
sMultiplier2 = sMultiplier2pt1*eta
deltaSigmaStarUSCOREx2 = deltaSigmaStarUSCOREx1+sMultiplier1*sigmaStar0+sMultiplier2*sigmaKerr0
deltaSigmaStarUSCOREy2 = deltaSigmaStarUSCOREy1+sMultiplier1*sigmaStar1+sMultiplier2*sigmaKerr1
deltaSigmaStarUSCOREz2 = deltaSigmaStarUSCOREz1+sMultiplier1*sigmaStar2+sMultiplier2*sigmaKerr2
deltaSigmaStarUSCOREx = deltaSigmaStarUSCOREx2+d1v2*sigmaKerr0*etau3
deltaSigmaStarUSCOREy = deltaSigmaStarUSCOREy2+d1v2*sigmaKerr1*etau3
deltaSigmaStarUSCOREz = deltaSigmaStarUSCOREz2+d1v2*sigmaKerr2*etau3
sx = sStarUSCOREx+deltaSigmaStarUSCOREx
sy = sStarUSCOREy+deltaSigmaStarUSCOREy
sz = sStarUSCOREz+deltaSigmaStarUSCOREz
sxi = sx*xiUSCOREx+sy*xiUSCOREy+sz*xiUSCOREz
sv = sx*vx+sy*vy+sz*vz
sn = sx*nx+sy*ny+sz*nz
s3 = sx*e3USCOREx+sy*e3USCOREy+sz*e3USCOREz
sqrtQ = sp.sqrt(Q)
oneplus2sqrtQ = 1+2*sqrtQ
oneplus1sqrtQ = oneplus2sqrtQ-sqrtQ
twoB1psqrtQsqrtQ = (2*B*oneplus1sqrtQ*sqrtQ)
invtwoB1psqrtQsqrtQ = 1/twoB1psqrtQsqrtQ
expMUsqsqrtQplusQ = (expMUsq)*(sqrtQ+Q)
Hwrpt4a = pxirsq*sv
Hwrpt4 = expMUsqexpnusq*Hwrpt4a
Hwrpt3c = pxir*sxi
Hwrpt3b = pvr*Hwrpt3c
Hwrpt3a = expMUexpnu*Hwrpt3b
Hwrpt3 = B*Hwrpt3a
Hwrpt2g = sv*deltaR
Hwrpt2f = sn*sqrtdeltaR
Hwrpt2e = pvr*Hwrpt2f
Hwrpt2d = pnsq*Hwrpt2g
Hwrpt2c = pn*Hwrpt2e
Hwrpt2b = expMUsqsqrtQplusQ*sv
Hwrpt2a = xi2*(Hwrpt2b+Hwrpt2c-Hwrpt2d)
Hwrpt2 = deltaT*Hwrpt2a
Hwrpt1b = invtwoB1psqrtQsqrtQ*invxi2
Hwrpt1a = sqrtdeltaR*Hwrpt1b
Hwrpt1 = invexpMUcubinvexpnu*Hwrpt1a
Hwr = (Hwrpt4-Hwrpt3+Hwrpt2)*Hwrpt1
Hwcospt9 = pxir*sxi
Hwcospt8 = pvr*sv
Hwcospt7 = (B*Hwcospt8-(expMUexpnu)*Hwcospt9)
Hwcospt6 = sqrtdeltaR*Hwcospt7
Hwcospt5 = (pvrsq-expMUsqsqrtQplusQ*xi2)
Hwcospt4 = pn*Hwcospt6
Hwcospt3 = -(expMUsqexpnusq*pxirsq)+deltaT*Hwcospt5
Hwcospt2 = sn*Hwcospt3-B*Hwcospt4
Hwcospt1 = invexpMUcubinvexpnu*Hwcospt2
Hwcos = invtwoB1psqrtQsqrtQ*Hwcospt1
deltaTsqrtQ = deltaT*sqrtQ
invdeltatTsqrtQ = 1/deltaTsqrtQ
HSOLpt5 = (-B+(expMUexpnu))*pxir
HSOLpt4 = invexpMU*HSOLpt5
HSOLpt3 = expnusq*HSOLpt4
HSOLpt2 = (HSOLpt3*s3)
HSOLpt1 = HSOLpt2*invxi2
HSOL = HSOLpt1*invdeltatTsqrtQ
deltaTsqrtQplusQ = (deltaT*(sqrtQ+Q))
invdeltaTsqrtQplusQ = 1/deltaTsqrtQplusQ
HSONLmult2 = invxi2*invdeltaTsqrtQplusQ
HSONLmult = expnuinvexpMU2*HSONLmult2
HSONLpt1b = pn*xi2
HSONLpt1a = (mur*pvr-nur*pvr+(-mucos+nucos)*HSONLpt1b)
HSONLpt1 = mur*pvr-(mucos*HSONLpt1b)+sqrtQ*HSONLpt1a
HSONLpt2d = nur*pxir
HSONLpt2c = oneplus2sqrtQ*HSONLpt2d
HSONLpt2b = B*sxi
HSONLpt2a = expMUexpnu*HSONLpt2c
HSONLpt2 = (sv*HSONLpt2a+HSONLpt1*HSONLpt2b)
HSONLpt3c = sv*pxir
HSONLpt3b = oneplus1sqrtQ*HSONLpt3c
HSONLpt3a = expMUexpnu*HSONLpt3b
HSONLpt3 = -BR*HSONLpt3a+B*HSONLpt2
HSONLpt4e = sn*xi2
HSONLpt4d = oneplus2sqrtQ*HSONLpt4e
HSONLpt4c = pxir*HSONLpt4d
HSONLpt4b = nucos*HSONLpt4c
HSONLpt4a = expMUexpnu*HSONLpt4b
HSONLpt4 = (-(B*HSONLpt4a)+HSONLpt3*sqrtdeltaR)
HSONL = HSONLmult*HSONLpt4
Hs = w*s3+Hwr*wr+Hwcos*wcos+HSOL+HSONL
Hsspt1 = sp.Rational(-1,2)*(sx*sx+sy*sy+sz*sz-3*sn*sn)
Hss = u3*Hsspt1
sKerrdotsStar = (sKerrUSCOREx*sStarUSCOREx+sKerrUSCOREy*sStarUSCOREy+sKerrUSCOREz*sStarUSCOREz)
Hpt1 = etau4*(s1dots1+s2dots2)
H = Hns+Hs+Hss+dheffSSv2*Hpt1
Hreal = sp.sqrt(1+2*eta*(sp.Abs(H)-1))
r2prm_x = 2*x
rprm_x = r2prm_x/(2*sp.sqrt(r2))
uprm_x = -rprm_x/r**2
u2prm_x = 2*u*uprm_x
u3prm_x = u*u2prm_x + u2*uprm_x
u4prm_x = 2*u2*u2prm_x
u5prm_x = u*u4prm_x + u4*uprm_x
etau3prm_x = eta*u3prm_x
etau4prm_x = eta*u4prm_x
nxprm_x = u + uprm_x*x
nyprm_x = uprm_x*y
nzprm_x = uprm_x*z
costhetaprm_x = e3USCOREx*nxprm_x + e3USCOREy*nyprm_x + e3USCOREz*nzprm_x
xi2prm_x = -2*costheta*costhetaprm_x
xiUSCORExprm_x = e3USCOREy*nzprm_x - e3USCOREz*nyprm_x
xiUSCOREyprm_x = -e3USCOREx*nzprm_x + e3USCOREz*nxprm_x
xiUSCOREzprm_x = e3USCOREx*nyprm_x - e3USCOREy*nxprm_x
vxprm_x = ny*xiUSCOREzprm_x + nyprm_x*xiUSCOREz - nz*xiUSCOREyprm_x - nzprm_x*xiUSCOREy
vyprm_x = -nx*xiUSCOREzprm_x - nxprm_x*xiUSCOREz + nz*xiUSCORExprm_x + nzprm_x*xiUSCOREx
vzprm_x = nx*xiUSCOREyprm_x + nxprm_x*xiUSCOREy - ny*xiUSCORExprm_x - nyprm_x*xiUSCOREx
w2prm_x = r2prm_x
rho2prm_x = 2*a2*costheta*costhetaprm_x + r2prm_x
bulkprm_x = a2*u2prm_x + 2*invm1PlusetaKK*uprm_x
loguprm_x = uprm_x/u
logargprm_x = k1*uprm_x + k2*u2prm_x + k3*u3prm_x + k4*u4prm_x + k5*u5prm_x + k5l*logu*u5prm_x + k5l*loguprm_x*u5
onepluslogargprm_x = logargprm_x
invonepluslogargprm_x = -onepluslogargprm_x/onepluslogarg**2
logTermsprm_x = eta*onepluslogargprm_x*sp.sign(onepluslogarg)/sp.Abs(onepluslogarg)
deltaUprm_x = (bulk*logTermsprm_x + bulkprm_x*logTerms)*sp.sign(bulk*logTerms)
deltaTprm_x = deltaU*r2prm_x + deltaUprm_x*r2
deltaUUSCOREupt7prm_x = k5l*loguprm_x
deltaUUSCOREupt6prm_x = 5*deltaUUSCOREupt7*uprm_x + 5*deltaUUSCOREupt7prm_x*u
deltaUUSCOREupt5prm_x = deltaUUSCOREupt6*uprm_x + deltaUUSCOREupt6prm_x*u
deltaUUSCOREupt4prm_x = deltaUUSCOREupt5*uprm_x + deltaUUSCOREupt5prm_x*u
deltaUUSCOREupt3prm_x = deltaUUSCOREupt4*uprm_x + deltaUUSCOREupt4prm_x*u
deltaUUSCOREupt2prm_x = a2*uprm_x
deltaUUSCOREupt1prm_x = bulk*deltaUUSCOREupt3prm_x*eta + bulkprm_x*deltaUUSCOREupt3*eta
deltaUUSCOREuprm_x = deltaUUSCOREupt1*invonepluslogargprm_x + deltaUUSCOREupt1prm_x*invonepluslogarg + 2*deltaUUSCOREupt2*logTermsprm_x + 2*deltaUUSCOREupt2prm_x*logTerms
deltaTUSCORErprm_x = 2*deltaU*rprm_x - deltaUUSCOREuprm_x + 2*deltaUprm_x*r
Lambprm_x = (a2*deltaT*xi2prm_x + a2*deltaTprm_x*xi2 - 2*w2*w2prm_x)*sp.sign(a2*deltaT*xi2 - w2**2)
rho2xi2Lambprm_x = Lamb*rho2*xi2prm_x + Lamb*rho2prm_x*xi2 + Lambprm_x*rho2*xi2
invrho2xi2Lambprm_x = -rho2xi2Lambprm_x/rho2xi2Lamb**2
invrho2prm_x = -rho2prm_x/rho2**2
invxi2prm_x = -xi2prm_x/xi2**2
invLambprm_x = -Lambprm_x/Lamb**2
invLambsqprm_x = 2*invLamb*invLambprm_x
rho2invLambprm_x = invLamb*rho2prm_x + invLambprm_x*rho2
expnuprm_x = sp.sqrt(deltaT*rho2invLamb)*(deltaT*rho2invLambprm_x/2 + deltaTprm_x*rho2invLamb/2)/(deltaT*rho2invLamb)
expMUprm_x = rho2prm_x/(2*sp.sqrt(rho2))
expMUexpnuprm_x = expMU*expnuprm_x + expMUprm_x*expnu
expMUsqprm_x = 2*expMU*expMUprm_x
expnusqprm_x = 2*expnu*expnuprm_x
expMUsqexpnusqprm_x = expMUsq*expnusqprm_x + expMUsqprm_x*expnusq
invexpnuexpMUprm_x = -expMUexpnuprm_x/expMUexpnu**2
invexpMUprm_x = expnu*invexpnuexpMUprm_x + expnuprm_x*invexpnuexpMU
invexpMUsqprm_x = 2*invexpMU*invexpMUprm_x
expnuinvexpMU2prm_x = expnu*invexpMUsqprm_x + expnuprm_x*invexpMUsq
invexpMUcubinvexpnuprm_x = invexpMUsq*invexpnuexpMUprm_x + invexpMUsqprm_x*invexpnuexpMU
DDprm_x = (6*eta*u2prm_x + etau3prm_x*(52 - 6*eta))/(6*eta*u2 + etau3*(52 - 6*eta) + 1)
deltaRprm_x = DD*deltaTprm_x + DDprm_x*deltaT
wwprm_x = a*a2*b3*eta*uprm_x + a*bb3*eta*uprm_x + 2*a*rprm_x
Bprm_x = deltaTprm_x/(2*sp.sqrt(deltaT))
sqrtdeltaTprm_x = Bprm_x
sqrtdeltaRprm_x = deltaRprm_x/(2*sp.sqrt(deltaR))
deltaTsqrtdeltaRprm_x = deltaT*sqrtdeltaRprm_x + deltaTprm_x*sqrtdeltaR
sqrtdeltaTdeltaTsqrtdeltaRprm_x = deltaTsqrtdeltaR*sqrtdeltaTprm_x + deltaTsqrtdeltaRprm_x*sqrtdeltaT
invdeltaTsqrtdeltaTsqrtdeltaRprm_x = -1.0*sqrtdeltaTdeltaTsqrtdeltaRprm_x/sqrtdeltaTdeltaTsqrtdeltaR**2
invdeltaTprm_x = invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaR*sqrtdeltaTprm_x + invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaRprm_x*sqrtdeltaT + invdeltaTsqrtdeltaTsqrtdeltaRprm_x*sqrtdeltaR*sqrtdeltaT
invsqrtdeltaTprm_x = deltaTsqrtdeltaR*invdeltaTsqrtdeltaTsqrtdeltaRprm_x + deltaTsqrtdeltaRprm_x*invdeltaTsqrtdeltaTsqrtdeltaR
invsqrtdeltaRprm_x = deltaT*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaTprm_x + deltaT*invdeltaTsqrtdeltaTsqrtdeltaRprm_x*sqrtdeltaT + deltaTprm_x*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaT
wprm_x = invLamb*wwprm_x + invLambprm_x*ww
LambUSCORErprm_x = -a2*deltaTUSCOREr*xi2prm_x - a2*deltaTUSCORErprm_x*xi2 + 4*r*w2prm_x + 4*rprm_x*w2
wwUSCORErprm_x = -a*a2*b3*eta*u2prm_x - a*bb3*eta*u2prm_x
BRprm_x = invsqrtdeltaT*(-deltaT*invsqrtdeltaRprm_x + deltaTUSCORErprm_x/2 - deltaTprm_x*invsqrtdeltaR) + invsqrtdeltaTprm_x*(-deltaT*invsqrtdeltaR + deltaTUSCOREr/2)
wrprm_x = invLambsq*(Lamb*wwUSCORErprm_x - LambUSCOREr*wwprm_x - LambUSCORErprm_x*ww + Lambprm_x*wwUSCOREr) + invLambsqprm_x*(Lamb*wwUSCOREr - LambUSCOREr*ww)
nurpt2prm_x = w2*(-4.0*deltaT*rprm_x + deltaTUSCOREr*w2prm_x + deltaTUSCORErprm_x*w2 - 4.0*deltaTprm_x*r) + w2prm_x*(-4.0*deltaT*r + deltaTUSCOREr*w2)
nurpt1prm_x = invdeltaT*nurpt2prm_x + invdeltaTprm_x*nurpt2
nurprm_x = invLamb*nurpt1prm_x/2 + invLambprm_x*nurpt1/2 + invrho2*rprm_x + invrho2prm_x*r
murprm_x = invrho2*rprm_x + invrho2prm_x*r - invsqrtdeltaRprm_x
a2costhetaprm_x = a2*costhetaprm_x
wcospt2prm_x = deltaT*wwprm_x + deltaTprm_x*ww
wcospt1prm_x = invLambsq*wcospt2prm_x + invLambsqprm_x*wcospt2
wcosprm_x = -2*a2costheta*wcospt1prm_x - 2*a2costhetaprm_x*wcospt1
nucospt3prm_x = invLamb*invrho2prm_x + invLambprm_x*invrho2
nucospt2prm_x = nucospt3*w2prm_x + nucospt3prm_x*w2
nucospt1prm_x = a2costheta*nucospt2prm_x + a2costhetaprm_x*nucospt2
nucosprm_x = nucospt1*(-deltaTprm_x + w2prm_x) + nucospt1prm_x*(-deltaT + w2)
mucosprm_x = a2costheta*invrho2prm_x + a2costhetaprm_x*invrho2
etaover12rprm_x = eta*uprm_x/12
csiprm_x = (deltaR*deltaTprm_x + deltaRprm_x*deltaT)*sp.sign(deltaR*deltaT)/(2*w2*sp.sqrt(sp.Abs(deltaR*deltaT))) - w2prm_x*sp.sqrt(sp.Abs(deltaR*deltaT))/w2**2
csi1prm_x = csiprm_x*(1 - sp.Abs(tortoise - 1))
csi2prm_x = csiprm_x*(1/2 - 0.5*sp.sign(1.5 - tortoise))
prTprm_x = csi2*(nxprm_x*px + nyprm_x*py + nzprm_x*pz) + csi2prm_x*(nx*px + ny*py + nz*pz)
prTtimesoneminuscsi1invprm_x = prTprm_x*(1 - 1/csi1) + csi1prm_x*prT/csi1**2
tmppxprm_x = -nx*prTtimesoneminuscsi1invprm_x - nxprm_x*prTtimesoneminuscsi1inv
tmppyprm_x = -ny*prTtimesoneminuscsi1invprm_x - nyprm_x*prTtimesoneminuscsi1inv
tmppzprm_x = -nz*prTtimesoneminuscsi1invprm_x - nzprm_x*prTtimesoneminuscsi1inv
pxirprm_x = r*(tmppx*xiUSCORExprm_x + tmppxprm_x*xiUSCOREx + tmppy*xiUSCOREyprm_x + tmppyprm_x*xiUSCOREy + tmppz*xiUSCOREzprm_x + tmppzprm_x*xiUSCOREz) + rprm_x*(tmppx*xiUSCOREx + tmppy*xiUSCOREy + tmppz*xiUSCOREz)
pvrprm_x = r*(tmppx*vxprm_x + tmppxprm_x*vx + tmppy*vyprm_x + tmppyprm_x*vy + tmppz*vzprm_x + tmppzprm_x*vz) + rprm_x*(tmppx*vx + tmppy*vy + tmppz*vz)
pvrsqprm_x = 2*pvr*pvrprm_x
pnprm_x = nx*tmppxprm_x + nxprm_x*tmppx + ny*tmppyprm_x + nyprm_x*tmppy + nz*tmppzprm_x + nzprm_x*tmppz
pnsqprm_x = 2*pn*pnprm_x
prprm_x = pnprm_x
prsqprm_x = 2*pr*prprm_x
pfprm_x = pxirprm_x
pxirsqprm_x = 2*pxir*pxirprm_x
ptheta2prm_x = invxi2*pvrsqprm_x + invxi2prm_x*pvrsq
prT4prm_x = 4*prT**3*prTprm_x
Hnspt7prm_x = deltaR*invrho2prm_x + deltaRprm_x*invrho2
Hnspt6prm_x = invxi2*rho2invLambprm_x + invxi2prm_x*rho2invLamb
Hnspt5prm_x = qq*u2prm_x
Hnspt4prm_x = Hnspt5*prT4prm_x + Hnspt5prm_x*prT4 + 2*Hnspt6*pf*pfprm_x + Hnspt6prm_x*pf**2 + Hnspt7*prsqprm_x + Hnspt7prm_x*prsq + invrho2*ptheta2prm_x + invrho2prm_x*ptheta2
Hnspt3prm_x = Hnspt4*deltaTprm_x + Hnspt4prm_x*deltaT
Hnspt2prm_x = Hnspt3*rho2prm_x + Hnspt3prm_x*rho2
Hnspt1prm_x = pf*wwprm_x + pfprm_x*ww
Hnsprm_x = Hnspt1*invLambprm_x + Hnspt1prm_x*invLamb + sp.sqrt(Hnspt2*invLamb)*(Hnspt2*invLambprm_x/2 + Hnspt2prm_x*invLamb/2)/(Hnspt2*invLamb)
Qpt3prm_x = deltaR*invrho2prm_x + deltaRprm_x*invrho2
Qpt2prm_x = invxi2*rho2invLambprm_x + invxi2prm_x*rho2invLamb
Qpt1prm_x = invrho2*invxi2prm_x + invrho2prm_x*invxi2
Qprm_x = Qpt1*pvrsqprm_x + Qpt1prm_x*pvrsq + Qpt2*pxirsqprm_x + Qpt2prm_x*pxirsq + Qpt3*pnsqprm_x + Qpt3prm_x*pnsq
pn2prm_x = deltaR*invrho2*prsqprm_x + deltaR*invrho2prm_x*prsq + deltaRprm_x*invrho2*prsq
ppprm_x = Qprm_x
sKerrmultfactprm_x = r*(-36*pn2prm_x + 3*ppprm_x) + rprm_x*(-36*pn2 + 3*pp)
sStarmultfactprm_x = r*(-30*pn2prm_x + 4*ppprm_x) + rprm_x*(-30*pn2 + 4*pp)
deltaSigmaStarUSCOREx1prm_x = etaover12r*(sKerrUSCOREx*sKerrmultfactprm_x + sStarUSCOREx*sStarmultfactprm_x) + etaover12rprm_x*(sKerrUSCOREx*sKerrmultfact + sStarUSCOREx*sStarmultfact)
deltaSigmaStarUSCOREy1prm_x = etaover12r*(sKerrUSCOREy*sKerrmultfactprm_x + sStarUSCOREy*sStarmultfactprm_x) + etaover12rprm_x*(sKerrUSCOREy*sKerrmultfact + sStarUSCOREy*sStarmultfact)
deltaSigmaStarUSCOREz1prm_x = etaover12r*(sKerrUSCOREz*sKerrmultfactprm_x + sStarUSCOREz*sStarmultfactprm_x) + etaover12rprm_x*(sKerrUSCOREz*sKerrmultfact + sStarUSCOREz*sStarmultfact)
pn2ppprm_x = pn2*ppprm_x + pn2prm_x*pp
pp2prm_x = 2*pp*ppprm_x
pn2u2prm_x = pn2*u2prm_x + pn2prm_x*u2
ppu2prm_x = pp*u2prm_x + ppprm_x*u2
pn2ppu2prm_x = pn2pp*u2prm_x + pn2ppprm_x*u2
sMultiplier1pt6prm_x = -720*pn2*pn2prm_x + 126*pn2ppprm_x + 3*pp2prm_x
sMultiplier1pt5prm_x = -96*pn2ppprm_x + 23*pp2prm_x
sMultiplier1pt4prm_x = 324*pn2prm_x - 120*ppprm_x + r*sMultiplier1pt6prm_x + rprm_x*sMultiplier1pt6
sMultiplier1pt3prm_x = -282*pn2prm_x + 206*ppprm_x + r*sMultiplier1pt5prm_x + rprm_x*sMultiplier1pt5
sMultiplier1pt2prm_x = r*sMultiplier1pt4prm_x + rprm_x*sMultiplier1pt4
sMultiplier1pt1prm_x = eta*sMultiplier1pt2prm_x + r*sMultiplier1pt3prm_x + rprm_x*sMultiplier1pt3
sMultiplier1prm_x = -eta*sMultiplier1pt1*u2prm_x/72 - eta*sMultiplier1pt1prm_x*u2/72
sMultiplier2pt6prm_x = 45*pn2*pn2u2prm_x/8 - 13*pn2ppu2prm_x/8 + 45*pn2prm_x*pn2u2/8
sMultiplier2pt5prm_x = pn2ppu2prm_x/4 - 5*pp2*u2prm_x/16 - 5*pp2prm_x*u2/16
sMultiplier2pt4prm_x = -49*pn2u2prm_x/8 + 17*ppu2prm_x/12 + r*sMultiplier2pt6prm_x + rprm_x*sMultiplier2pt6
sMultiplier2pt3prm_x = -2*pn2u2prm_x/3 - 109*ppu2prm_x/36 + r*sMultiplier2pt5prm_x + rprm_x*sMultiplier2pt5
sMultiplier2pt2prm_x = r*sMultiplier2pt4prm_x + rprm_x*sMultiplier2pt4 - 7*u2prm_x/3
sMultiplier2pt1prm_x = eta*sMultiplier2pt2prm_x + r*sMultiplier2pt3prm_x + rprm_x*sMultiplier2pt3 - 56*u2prm_x/9
sMultiplier2prm_x = eta*sMultiplier2pt1prm_x
deltaSigmaStarUSCOREx2prm_x = deltaSigmaStarUSCOREx1prm_x + sMultiplier1prm_x*sigmaStar0 + sMultiplier2prm_x*sigmaKerr0
deltaSigmaStarUSCOREy2prm_x = deltaSigmaStarUSCOREy1prm_x + sMultiplier1prm_x*sigmaStar1 + sMultiplier2prm_x*sigmaKerr1
deltaSigmaStarUSCOREz2prm_x = deltaSigmaStarUSCOREz1prm_x + sMultiplier1prm_x*sigmaStar2 + sMultiplier2prm_x*sigmaKerr2
deltaSigmaStarUSCORExprm_x = d1v2*etau3prm_x*sigmaKerr0 + deltaSigmaStarUSCOREx2prm_x
deltaSigmaStarUSCOREyprm_x = d1v2*etau3prm_x*sigmaKerr1 + deltaSigmaStarUSCOREy2prm_x
deltaSigmaStarUSCOREzprm_x = d1v2*etau3prm_x*sigmaKerr2 + deltaSigmaStarUSCOREz2prm_x
sxprm_x = deltaSigmaStarUSCORExprm_x
syprm_x = deltaSigmaStarUSCOREyprm_x
szprm_x = deltaSigmaStarUSCOREzprm_x
sxiprm_x = sx*xiUSCORExprm_x + sxprm_x*xiUSCOREx + sy*xiUSCOREyprm_x + syprm_x*xiUSCOREy + sz*xiUSCOREzprm_x + szprm_x*xiUSCOREz
svprm_x = sx*vxprm_x + sxprm_x*vx + sy*vyprm_x + syprm_x*vy + sz*vzprm_x + szprm_x*vz
snprm_x = nx*sxprm_x + nxprm_x*sx + ny*syprm_x + nyprm_x*sy + nz*szprm_x + nzprm_x*sz
s3prm_x = e3USCOREx*sxprm_x + e3USCOREy*syprm_x + e3USCOREz*szprm_x
sqrtQprm_x = Qprm_x/(2*sp.sqrt(Q))
oneplus2sqrtQprm_x = 2*sqrtQprm_x
oneplus1sqrtQprm_x = oneplus2sqrtQprm_x - sqrtQprm_x
twoB1psqrtQsqrtQprm_x = 2*B*oneplus1sqrtQ*sqrtQprm_x + 2*B*oneplus1sqrtQprm_x*sqrtQ + 2*Bprm_x*oneplus1sqrtQ*sqrtQ
invtwoB1psqrtQsqrtQprm_x = -twoB1psqrtQsqrtQprm_x/twoB1psqrtQsqrtQ**2
expMUsqsqrtQplusQprm_x = expMUsq*(Qprm_x + sqrtQprm_x) + expMUsqprm_x*(Q + sqrtQ)
Hwrpt4aprm_x = pxirsq*svprm_x + pxirsqprm_x*sv
Hwrpt4prm_x = Hwrpt4a*expMUsqexpnusqprm_x + Hwrpt4aprm_x*expMUsqexpnusq
Hwrpt3cprm_x = pxir*sxiprm_x + pxirprm_x*sxi
Hwrpt3bprm_x = Hwrpt3c*pvrprm_x + Hwrpt3cprm_x*pvr
Hwrpt3aprm_x = Hwrpt3b*expMUexpnuprm_x + Hwrpt3bprm_x*expMUexpnu
Hwrpt3prm_x = B*Hwrpt3aprm_x + Bprm_x*Hwrpt3a
Hwrpt2gprm_x = deltaR*svprm_x + deltaRprm_x*sv
Hwrpt2fprm_x = sn*sqrtdeltaRprm_x + snprm_x*sqrtdeltaR
Hwrpt2eprm_x = Hwrpt2f*pvrprm_x + Hwrpt2fprm_x*pvr
Hwrpt2dprm_x = Hwrpt2g*pnsqprm_x + Hwrpt2gprm_x*pnsq
Hwrpt2cprm_x = Hwrpt2e*pnprm_x + Hwrpt2eprm_x*pn
Hwrpt2bprm_x = expMUsqsqrtQplusQ*svprm_x + expMUsqsqrtQplusQprm_x*sv
Hwrpt2aprm_x = xi2*(Hwrpt2bprm_x + Hwrpt2cprm_x - Hwrpt2dprm_x) + xi2prm_x*(Hwrpt2b + Hwrpt2c - Hwrpt2d)
Hwrpt2prm_x = Hwrpt2a*deltaTprm_x + Hwrpt2aprm_x*deltaT
Hwrpt1bprm_x = invtwoB1psqrtQsqrtQ*invxi2prm_x + invtwoB1psqrtQsqrtQprm_x*invxi2
Hwrpt1aprm_x = Hwrpt1b*sqrtdeltaRprm_x + Hwrpt1bprm_x*sqrtdeltaR
Hwrpt1prm_x = Hwrpt1a*invexpMUcubinvexpnuprm_x + Hwrpt1aprm_x*invexpMUcubinvexpnu
Hwrprm_x = Hwrpt1*(Hwrpt2prm_x - Hwrpt3prm_x + Hwrpt4prm_x) + Hwrpt1prm_x*(Hwrpt2 - Hwrpt3 + Hwrpt4)
Hwcospt9prm_x = pxir*sxiprm_x + pxirprm_x*sxi
Hwcospt8prm_x = pvr*svprm_x + pvrprm_x*sv
Hwcospt7prm_x = B*Hwcospt8prm_x + Bprm_x*Hwcospt8 - Hwcospt9*expMUexpnuprm_x - Hwcospt9prm_x*expMUexpnu
Hwcospt6prm_x = Hwcospt7*sqrtdeltaRprm_x + Hwcospt7prm_x*sqrtdeltaR
Hwcospt5prm_x = -expMUsqsqrtQplusQ*xi2prm_x - expMUsqsqrtQplusQprm_x*xi2 + pvrsqprm_x
Hwcospt4prm_x = Hwcospt6*pnprm_x + Hwcospt6prm_x*pn
Hwcospt3prm_x = Hwcospt5*deltaTprm_x + Hwcospt5prm_x*deltaT - expMUsqexpnusq*pxirsqprm_x - expMUsqexpnusqprm_x*pxirsq
Hwcospt2prm_x = -B*Hwcospt4prm_x - Bprm_x*Hwcospt4 + Hwcospt3*snprm_x + Hwcospt3prm_x*sn
Hwcospt1prm_x = Hwcospt2*invexpMUcubinvexpnuprm_x + Hwcospt2prm_x*invexpMUcubinvexpnu
Hwcosprm_x = Hwcospt1*invtwoB1psqrtQsqrtQprm_x + Hwcospt1prm_x*invtwoB1psqrtQsqrtQ
deltaTsqrtQprm_x = deltaT*sqrtQprm_x + deltaTprm_x*sqrtQ
invdeltatTsqrtQprm_x = -deltaTsqrtQprm_x/deltaTsqrtQ**2
HSOLpt5prm_x = pxir*(-Bprm_x + expMUexpnuprm_x) + pxirprm_x*(-B + expMUexpnu)
HSOLpt4prm_x = HSOLpt5*invexpMUprm_x + HSOLpt5prm_x*invexpMU
HSOLpt3prm_x = HSOLpt4*expnusqprm_x + HSOLpt4prm_x*expnusq
HSOLpt2prm_x = HSOLpt3*s3prm_x + HSOLpt3prm_x*s3
HSOLpt1prm_x = HSOLpt2*invxi2prm_x + HSOLpt2prm_x*invxi2
HSOLprm_x = HSOLpt1*invdeltatTsqrtQprm_x + HSOLpt1prm_x*invdeltatTsqrtQ
deltaTsqrtQplusQprm_x = deltaT*(Qprm_x + sqrtQprm_x) + deltaTprm_x*(Q + sqrtQ)
invdeltaTsqrtQplusQprm_x = -deltaTsqrtQplusQprm_x/deltaTsqrtQplusQ**2
HSONLmult2prm_x = invdeltaTsqrtQplusQ*invxi2prm_x + invdeltaTsqrtQplusQprm_x*invxi2
HSONLmultprm_x = HSONLmult2*expnuinvexpMU2prm_x + HSONLmult2prm_x*expnuinvexpMU2
HSONLpt1bprm_x = pn*xi2prm_x + pnprm_x*xi2
HSONLpt1aprm_x = HSONLpt1b*(-mucosprm_x + nucosprm_x) + HSONLpt1bprm_x*(-mucos + nucos) + mur*pvrprm_x + murprm_x*pvr - nur*pvrprm_x - nurprm_x*pvr
HSONLpt1prm_x = HSONLpt1a*sqrtQprm_x + HSONLpt1aprm_x*sqrtQ - HSONLpt1b*mucosprm_x - HSONLpt1bprm_x*mucos + mur*pvrprm_x + murprm_x*pvr
HSONLpt2dprm_x = nur*pxirprm_x + nurprm_x*pxir
HSONLpt2cprm_x = HSONLpt2d*oneplus2sqrtQprm_x + HSONLpt2dprm_x*oneplus2sqrtQ
HSONLpt2bprm_x = B*sxiprm_x + Bprm_x*sxi
HSONLpt2aprm_x = HSONLpt2c*expMUexpnuprm_x + HSONLpt2cprm_x*expMUexpnu
HSONLpt2prm_x = HSONLpt1*HSONLpt2bprm_x + HSONLpt1prm_x*HSONLpt2b + HSONLpt2a*svprm_x + HSONLpt2aprm_x*sv
HSONLpt3cprm_x = pxir*svprm_x + pxirprm_x*sv
HSONLpt3bprm_x = HSONLpt3c*oneplus1sqrtQprm_x + HSONLpt3cprm_x*oneplus1sqrtQ
HSONLpt3aprm_x = HSONLpt3b*expMUexpnuprm_x + HSONLpt3bprm_x*expMUexpnu
HSONLpt3prm_x = B*HSONLpt2prm_x - BR*HSONLpt3aprm_x - BRprm_x*HSONLpt3a + Bprm_x*HSONLpt2
HSONLpt4eprm_x = sn*xi2prm_x + snprm_x*xi2
HSONLpt4dprm_x = HSONLpt4e*oneplus2sqrtQprm_x + HSONLpt4eprm_x*oneplus2sqrtQ
HSONLpt4cprm_x = HSONLpt4d*pxirprm_x + HSONLpt4dprm_x*pxir
HSONLpt4bprm_x = HSONLpt4c*nucosprm_x + HSONLpt4cprm_x*nucos
HSONLpt4aprm_x = HSONLpt4b*expMUexpnuprm_x + HSONLpt4bprm_x*expMUexpnu
HSONLpt4prm_x = -B*HSONLpt4aprm_x - Bprm_x*HSONLpt4a + HSONLpt3*sqrtdeltaRprm_x + HSONLpt3prm_x*sqrtdeltaR
HSONLprm_x = HSONLmult*HSONLpt4prm_x + HSONLmultprm_x*HSONLpt4
Hsprm_x = HSOLprm_x + HSONLprm_x + Hwcos*wcosprm_x + Hwcosprm_x*wcos + Hwr*wrprm_x + Hwrprm_x*wr + s3*wprm_x + s3prm_x*w
Hsspt1prm_x = 3*sn*snprm_x - sx*sxprm_x - sy*syprm_x - sz*szprm_x
Hssprm_x = Hsspt1*u3prm_x + Hsspt1prm_x*u3
Hpt1prm_x = etau4prm_x*(s1dots1 + s2dots2)
Hprm_x = Hnsprm_x + Hpt1prm_x*dheffSSv2 + Hsprm_x + Hssprm_x
Hrealprm_x = Hprm_x*eta*sp.sign(H)/sp.sqrt(2*eta*(sp.Abs(H) - 1) + 1)
r2prm_y = 2*y
rprm_y = r2prm_y/(2*sp.sqrt(r2))
uprm_y = -rprm_y/r**2
u2prm_y = 2*u*uprm_y
u3prm_y = u*u2prm_y + u2*uprm_y
u4prm_y = 2*u2*u2prm_y
u5prm_y = u*u4prm_y + u4*uprm_y
etau3prm_y = eta*u3prm_y
etau4prm_y = eta*u4prm_y
nxprm_y = uprm_y*x
nyprm_y = u + uprm_y*y
nzprm_y = uprm_y*z
costhetaprm_y = e3USCOREx*nxprm_y + e3USCOREy*nyprm_y + e3USCOREz*nzprm_y
xi2prm_y = -2*costheta*costhetaprm_y
xiUSCORExprm_y = e3USCOREy*nzprm_y - e3USCOREz*nyprm_y
xiUSCOREyprm_y = -e3USCOREx*nzprm_y + e3USCOREz*nxprm_y
xiUSCOREzprm_y = e3USCOREx*nyprm_y - e3USCOREy*nxprm_y
vxprm_y = ny*xiUSCOREzprm_y + nyprm_y*xiUSCOREz - nz*xiUSCOREyprm_y - nzprm_y*xiUSCOREy
vyprm_y = -nx*xiUSCOREzprm_y - nxprm_y*xiUSCOREz + nz*xiUSCORExprm_y + nzprm_y*xiUSCOREx
vzprm_y = nx*xiUSCOREyprm_y + nxprm_y*xiUSCOREy - ny*xiUSCORExprm_y - nyprm_y*xiUSCOREx
w2prm_y = r2prm_y
rho2prm_y = 2*a2*costheta*costhetaprm_y + r2prm_y
bulkprm_y = a2*u2prm_y + 2*invm1PlusetaKK*uprm_y
loguprm_y = uprm_y/u
logargprm_y = k1*uprm_y + k2*u2prm_y + k3*u3prm_y + k4*u4prm_y + k5*u5prm_y + k5l*logu*u5prm_y + k5l*loguprm_y*u5
onepluslogargprm_y = logargprm_y
invonepluslogargprm_y = -onepluslogargprm_y/onepluslogarg**2
logTermsprm_y = eta*onepluslogargprm_y*sp.sign(onepluslogarg)/sp.Abs(onepluslogarg)
deltaUprm_y = (bulk*logTermsprm_y + bulkprm_y*logTerms)*sp.sign(bulk*logTerms)
deltaTprm_y = deltaU*r2prm_y + deltaUprm_y*r2
deltaUUSCOREupt7prm_y = k5l*loguprm_y
deltaUUSCOREupt6prm_y = 5*deltaUUSCOREupt7*uprm_y + 5*deltaUUSCOREupt7prm_y*u
deltaUUSCOREupt5prm_y = deltaUUSCOREupt6*uprm_y + deltaUUSCOREupt6prm_y*u
deltaUUSCOREupt4prm_y = deltaUUSCOREupt5*uprm_y + deltaUUSCOREupt5prm_y*u
deltaUUSCOREupt3prm_y = deltaUUSCOREupt4*uprm_y + deltaUUSCOREupt4prm_y*u
deltaUUSCOREupt2prm_y = a2*uprm_y
deltaUUSCOREupt1prm_y = bulk*deltaUUSCOREupt3prm_y*eta + bulkprm_y*deltaUUSCOREupt3*eta
deltaUUSCOREuprm_y = deltaUUSCOREupt1*invonepluslogargprm_y + deltaUUSCOREupt1prm_y*invonepluslogarg + 2*deltaUUSCOREupt2*logTermsprm_y + 2*deltaUUSCOREupt2prm_y*logTerms
deltaTUSCORErprm_y = 2*deltaU*rprm_y - deltaUUSCOREuprm_y + 2*deltaUprm_y*r
Lambprm_y = (a2*deltaT*xi2prm_y + a2*deltaTprm_y*xi2 - 2*w2*w2prm_y)*sp.sign(a2*deltaT*xi2 - w2**2)
rho2xi2Lambprm_y = Lamb*rho2*xi2prm_y + Lamb*rho2prm_y*xi2 + Lambprm_y*rho2*xi2
invrho2xi2Lambprm_y = -rho2xi2Lambprm_y/rho2xi2Lamb**2
invrho2prm_y = -rho2prm_y/rho2**2
invxi2prm_y = -xi2prm_y/xi2**2
invLambprm_y = -Lambprm_y/Lamb**2
invLambsqprm_y = 2*invLamb*invLambprm_y
rho2invLambprm_y = invLamb*rho2prm_y + invLambprm_y*rho2
expnuprm_y = sp.sqrt(deltaT*rho2invLamb)*(deltaT*rho2invLambprm_y/2 + deltaTprm_y*rho2invLamb/2)/(deltaT*rho2invLamb)
expMUprm_y = rho2prm_y/(2*sp.sqrt(rho2))
expMUexpnuprm_y = expMU*expnuprm_y + expMUprm_y*expnu
expMUsqprm_y = 2*expMU*expMUprm_y
expnusqprm_y = 2*expnu*expnuprm_y
expMUsqexpnusqprm_y = expMUsq*expnusqprm_y + expMUsqprm_y*expnusq
invexpnuexpMUprm_y = -expMUexpnuprm_y/expMUexpnu**2
invexpMUprm_y = expnu*invexpnuexpMUprm_y + expnuprm_y*invexpnuexpMU
invexpMUsqprm_y = 2*invexpMU*invexpMUprm_y
expnuinvexpMU2prm_y = expnu*invexpMUsqprm_y + expnuprm_y*invexpMUsq
invexpMUcubinvexpnuprm_y = invexpMUsq*invexpnuexpMUprm_y + invexpMUsqprm_y*invexpnuexpMU
DDprm_y = (6*eta*u2prm_y + etau3prm_y*(52 - 6*eta))/(6*eta*u2 + etau3*(52 - 6*eta) + 1)
deltaRprm_y = DD*deltaTprm_y + DDprm_y*deltaT
wwprm_y = a*a2*b3*eta*uprm_y + a*bb3*eta*uprm_y + 2*a*rprm_y
Bprm_y = deltaTprm_y/(2*sp.sqrt(deltaT))
sqrtdeltaTprm_y = Bprm_y
sqrtdeltaRprm_y = deltaRprm_y/(2*sp.sqrt(deltaR))
deltaTsqrtdeltaRprm_y = deltaT*sqrtdeltaRprm_y + deltaTprm_y*sqrtdeltaR
sqrtdeltaTdeltaTsqrtdeltaRprm_y = deltaTsqrtdeltaR*sqrtdeltaTprm_y + deltaTsqrtdeltaRprm_y*sqrtdeltaT
invdeltaTsqrtdeltaTsqrtdeltaRprm_y = -1.0*sqrtdeltaTdeltaTsqrtdeltaRprm_y/sqrtdeltaTdeltaTsqrtdeltaR**2
invdeltaTprm_y = invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaR*sqrtdeltaTprm_y + invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaRprm_y*sqrtdeltaT + invdeltaTsqrtdeltaTsqrtdeltaRprm_y*sqrtdeltaR*sqrtdeltaT
invsqrtdeltaTprm_y = deltaTsqrtdeltaR*invdeltaTsqrtdeltaTsqrtdeltaRprm_y + deltaTsqrtdeltaRprm_y*invdeltaTsqrtdeltaTsqrtdeltaR
invsqrtdeltaRprm_y = deltaT*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaTprm_y + deltaT*invdeltaTsqrtdeltaTsqrtdeltaRprm_y*sqrtdeltaT + deltaTprm_y*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaT
wprm_y = invLamb*wwprm_y + invLambprm_y*ww
LambUSCORErprm_y = -a2*deltaTUSCOREr*xi2prm_y - a2*deltaTUSCORErprm_y*xi2 + 4*r*w2prm_y + 4*rprm_y*w2
wwUSCORErprm_y = -a*a2*b3*eta*u2prm_y - a*bb3*eta*u2prm_y
BRprm_y = invsqrtdeltaT*(-deltaT*invsqrtdeltaRprm_y + deltaTUSCORErprm_y/2 - deltaTprm_y*invsqrtdeltaR) + invsqrtdeltaTprm_y*(-deltaT*invsqrtdeltaR + deltaTUSCOREr/2)
wrprm_y = invLambsq*(Lamb*wwUSCORErprm_y - LambUSCOREr*wwprm_y - LambUSCORErprm_y*ww + Lambprm_y*wwUSCOREr) + invLambsqprm_y*(Lamb*wwUSCOREr - LambUSCOREr*ww)
nurpt2prm_y = w2*(-4.0*deltaT*rprm_y + deltaTUSCOREr*w2prm_y + deltaTUSCORErprm_y*w2 - 4.0*deltaTprm_y*r) + w2prm_y*(-4.0*deltaT*r + deltaTUSCOREr*w2)
nurpt1prm_y = invdeltaT*nurpt2prm_y + invdeltaTprm_y*nurpt2
nurprm_y = invLamb*nurpt1prm_y/2 + invLambprm_y*nurpt1/2 + invrho2*rprm_y + invrho2prm_y*r
murprm_y = invrho2*rprm_y + invrho2prm_y*r - invsqrtdeltaRprm_y
a2costhetaprm_y = a2*costhetaprm_y
wcospt2prm_y = deltaT*wwprm_y + deltaTprm_y*ww
wcospt1prm_y = invLambsq*wcospt2prm_y + invLambsqprm_y*wcospt2
wcosprm_y = -2*a2costheta*wcospt1prm_y - 2*a2costhetaprm_y*wcospt1
nucospt3prm_y = invLamb*invrho2prm_y + invLambprm_y*invrho2
nucospt2prm_y = nucospt3*w2prm_y + nucospt3prm_y*w2
nucospt1prm_y = a2costheta*nucospt2prm_y + a2costhetaprm_y*nucospt2
nucosprm_y = nucospt1*(-deltaTprm_y + w2prm_y) + nucospt1prm_y*(-deltaT + w2)
mucosprm_y = a2costheta*invrho2prm_y + a2costhetaprm_y*invrho2
etaover12rprm_y = eta*uprm_y/12
csiprm_y = (deltaR*deltaTprm_y + deltaRprm_y*deltaT)*sp.sign(deltaR*deltaT)/(2*w2*sp.sqrt(sp.Abs(deltaR*deltaT))) - w2prm_y*sp.sqrt(sp.Abs(deltaR*deltaT))/w2**2
csi1prm_y = csiprm_y*(1 - sp.Abs(tortoise - 1))
csi2prm_y = csiprm_y*(1/2 - 0.5*sp.sign(1.5 - tortoise))
prTprm_y = csi2*(nxprm_y*px + nyprm_y*py + nzprm_y*pz) + csi2prm_y*(nx*px + ny*py + nz*pz)
prTtimesoneminuscsi1invprm_y = prTprm_y*(1 - 1/csi1) + csi1prm_y*prT/csi1**2
tmppxprm_y = -nx*prTtimesoneminuscsi1invprm_y - nxprm_y*prTtimesoneminuscsi1inv
tmppyprm_y = -ny*prTtimesoneminuscsi1invprm_y - nyprm_y*prTtimesoneminuscsi1inv
tmppzprm_y = -nz*prTtimesoneminuscsi1invprm_y - nzprm_y*prTtimesoneminuscsi1inv
pxirprm_y = r*(tmppx*xiUSCORExprm_y + tmppxprm_y*xiUSCOREx + tmppy*xiUSCOREyprm_y + tmppyprm_y*xiUSCOREy + tmppz*xiUSCOREzprm_y + tmppzprm_y*xiUSCOREz) + rprm_y*(tmppx*xiUSCOREx + tmppy*xiUSCOREy + tmppz*xiUSCOREz)
pvrprm_y = r*(tmppx*vxprm_y + tmppxprm_y*vx + tmppy*vyprm_y + tmppyprm_y*vy + tmppz*vzprm_y + tmppzprm_y*vz) + rprm_y*(tmppx*vx + tmppy*vy + tmppz*vz)
pvrsqprm_y = 2*pvr*pvrprm_y
pnprm_y = nx*tmppxprm_y + nxprm_y*tmppx + ny*tmppyprm_y + nyprm_y*tmppy + nz*tmppzprm_y + nzprm_y*tmppz
pnsqprm_y = 2*pn*pnprm_y
prprm_y = pnprm_y
prsqprm_y = 2*pr*prprm_y
pfprm_y = pxirprm_y
pxirsqprm_y = 2*pxir*pxirprm_y
ptheta2prm_y = invxi2*pvrsqprm_y + invxi2prm_y*pvrsq
prT4prm_y = 4*prT**3*prTprm_y
Hnspt7prm_y = deltaR*invrho2prm_y + deltaRprm_y*invrho2
Hnspt6prm_y = invxi2*rho2invLambprm_y + invxi2prm_y*rho2invLamb
Hnspt5prm_y = qq*u2prm_y
Hnspt4prm_y = Hnspt5*prT4prm_y + Hnspt5prm_y*prT4 + 2*Hnspt6*pf*pfprm_y + Hnspt6prm_y*pf**2 + Hnspt7*prsqprm_y + Hnspt7prm_y*prsq + invrho2*ptheta2prm_y + invrho2prm_y*ptheta2
Hnspt3prm_y = Hnspt4*deltaTprm_y + Hnspt4prm_y*deltaT
Hnspt2prm_y = Hnspt3*rho2prm_y + Hnspt3prm_y*rho2
Hnspt1prm_y = pf*wwprm_y + pfprm_y*ww
Hnsprm_y = Hnspt1*invLambprm_y + Hnspt1prm_y*invLamb + sp.sqrt(Hnspt2*invLamb)*(Hnspt2*invLambprm_y/2 + Hnspt2prm_y*invLamb/2)/(Hnspt2*invLamb)
Qpt3prm_y = deltaR*invrho2prm_y + deltaRprm_y*invrho2
Qpt2prm_y = invxi2*rho2invLambprm_y + invxi2prm_y*rho2invLamb
Qpt1prm_y = invrho2*invxi2prm_y + invrho2prm_y*invxi2
Qprm_y = Qpt1*pvrsqprm_y + Qpt1prm_y*pvrsq + Qpt2*pxirsqprm_y + Qpt2prm_y*pxirsq + Qpt3*pnsqprm_y + Qpt3prm_y*pnsq
pn2prm_y = deltaR*invrho2*prsqprm_y + deltaR*invrho2prm_y*prsq + deltaRprm_y*invrho2*prsq
ppprm_y = Qprm_y
sKerrmultfactprm_y = r*(-36*pn2prm_y + 3*ppprm_y) + rprm_y*(-36*pn2 + 3*pp)
sStarmultfactprm_y = r*(-30*pn2prm_y + 4*ppprm_y) + rprm_y*(-30*pn2 + 4*pp)
deltaSigmaStarUSCOREx1prm_y = etaover12r*(sKerrUSCOREx*sKerrmultfactprm_y + sStarUSCOREx*sStarmultfactprm_y) + etaover12rprm_y*(sKerrUSCOREx*sKerrmultfact + sStarUSCOREx*sStarmultfact)
deltaSigmaStarUSCOREy1prm_y = etaover12r*(sKerrUSCOREy*sKerrmultfactprm_y + sStarUSCOREy*sStarmultfactprm_y) + etaover12rprm_y*(sKerrUSCOREy*sKerrmultfact + sStarUSCOREy*sStarmultfact)
deltaSigmaStarUSCOREz1prm_y = etaover12r*(sKerrUSCOREz*sKerrmultfactprm_y + sStarUSCOREz*sStarmultfactprm_y) + etaover12rprm_y*(sKerrUSCOREz*sKerrmultfact + sStarUSCOREz*sStarmultfact)
pn2ppprm_y = pn2*ppprm_y + pn2prm_y*pp
pp2prm_y = 2*pp*ppprm_y
pn2u2prm_y = pn2*u2prm_y + pn2prm_y*u2
ppu2prm_y = pp*u2prm_y + ppprm_y*u2
pn2ppu2prm_y = pn2pp*u2prm_y + pn2ppprm_y*u2
sMultiplier1pt6prm_y = -720*pn2*pn2prm_y + 126*pn2ppprm_y + 3*pp2prm_y
sMultiplier1pt5prm_y = -96*pn2ppprm_y + 23*pp2prm_y
sMultiplier1pt4prm_y = 324*pn2prm_y - 120*ppprm_y + r*sMultiplier1pt6prm_y + rprm_y*sMultiplier1pt6
sMultiplier1pt3prm_y = -282*pn2prm_y + 206*ppprm_y + r*sMultiplier1pt5prm_y + rprm_y*sMultiplier1pt5
sMultiplier1pt2prm_y = r*sMultiplier1pt4prm_y + rprm_y*sMultiplier1pt4
sMultiplier1pt1prm_y = eta*sMultiplier1pt2prm_y + r*sMultiplier1pt3prm_y + rprm_y*sMultiplier1pt3
sMultiplier1prm_y = -eta*sMultiplier1pt1*u2prm_y/72 - eta*sMultiplier1pt1prm_y*u2/72
sMultiplier2pt6prm_y = 45*pn2*pn2u2prm_y/8 - 13*pn2ppu2prm_y/8 + 45*pn2prm_y*pn2u2/8
sMultiplier2pt5prm_y = pn2ppu2prm_y/4 - 5*pp2*u2prm_y/16 - 5*pp2prm_y*u2/16
sMultiplier2pt4prm_y = -49*pn2u2prm_y/8 + 17*ppu2prm_y/12 + r*sMultiplier2pt6prm_y + rprm_y*sMultiplier2pt6
sMultiplier2pt3prm_y = -2*pn2u2prm_y/3 - 109*ppu2prm_y/36 + r*sMultiplier2pt5prm_y + rprm_y*sMultiplier2pt5
sMultiplier2pt2prm_y = r*sMultiplier2pt4prm_y + rprm_y*sMultiplier2pt4 - 7*u2prm_y/3
sMultiplier2pt1prm_y = eta*sMultiplier2pt2prm_y + r*sMultiplier2pt3prm_y + rprm_y*sMultiplier2pt3 - 56*u2prm_y/9
sMultiplier2prm_y = eta*sMultiplier2pt1prm_y
deltaSigmaStarUSCOREx2prm_y = deltaSigmaStarUSCOREx1prm_y + sMultiplier1prm_y*sigmaStar0 + sMultiplier2prm_y*sigmaKerr0
deltaSigmaStarUSCOREy2prm_y = deltaSigmaStarUSCOREy1prm_y + sMultiplier1prm_y*sigmaStar1 + sMultiplier2prm_y*sigmaKerr1
deltaSigmaStarUSCOREz2prm_y = deltaSigmaStarUSCOREz1prm_y + sMultiplier1prm_y*sigmaStar2 + sMultiplier2prm_y*sigmaKerr2
deltaSigmaStarUSCORExprm_y = d1v2*etau3prm_y*sigmaKerr0 + deltaSigmaStarUSCOREx2prm_y
deltaSigmaStarUSCOREyprm_y = d1v2*etau3prm_y*sigmaKerr1 + deltaSigmaStarUSCOREy2prm_y
deltaSigmaStarUSCOREzprm_y = d1v2*etau3prm_y*sigmaKerr2 + deltaSigmaStarUSCOREz2prm_y
sxprm_y = deltaSigmaStarUSCORExprm_y
syprm_y = deltaSigmaStarUSCOREyprm_y
szprm_y = deltaSigmaStarUSCOREzprm_y
sxiprm_y = sx*xiUSCORExprm_y + sxprm_y*xiUSCOREx + sy*xiUSCOREyprm_y + syprm_y*xiUSCOREy + sz*xiUSCOREzprm_y + szprm_y*xiUSCOREz
svprm_y = sx*vxprm_y + sxprm_y*vx + sy*vyprm_y + syprm_y*vy + sz*vzprm_y + szprm_y*vz
snprm_y = nx*sxprm_y + nxprm_y*sx + ny*syprm_y + nyprm_y*sy + nz*szprm_y + nzprm_y*sz
s3prm_y = e3USCOREx*sxprm_y + e3USCOREy*syprm_y + e3USCOREz*szprm_y
sqrtQprm_y = Qprm_y/(2*sp.sqrt(Q))
oneplus2sqrtQprm_y = 2*sqrtQprm_y
oneplus1sqrtQprm_y = oneplus2sqrtQprm_y - sqrtQprm_y
twoB1psqrtQsqrtQprm_y = 2*B*oneplus1sqrtQ*sqrtQprm_y + 2*B*oneplus1sqrtQprm_y*sqrtQ + 2*Bprm_y*oneplus1sqrtQ*sqrtQ
invtwoB1psqrtQsqrtQprm_y = -twoB1psqrtQsqrtQprm_y/twoB1psqrtQsqrtQ**2
expMUsqsqrtQplusQprm_y = expMUsq*(Qprm_y + sqrtQprm_y) + expMUsqprm_y*(Q + sqrtQ)
Hwrpt4aprm_y = pxirsq*svprm_y + pxirsqprm_y*sv
Hwrpt4prm_y = Hwrpt4a*expMUsqexpnusqprm_y + Hwrpt4aprm_y*expMUsqexpnusq
Hwrpt3cprm_y = pxir*sxiprm_y + pxirprm_y*sxi
Hwrpt3bprm_y = Hwrpt3c*pvrprm_y + Hwrpt3cprm_y*pvr
Hwrpt3aprm_y = Hwrpt3b*expMUexpnuprm_y + Hwrpt3bprm_y*expMUexpnu
Hwrpt3prm_y = B*Hwrpt3aprm_y + Bprm_y*Hwrpt3a
Hwrpt2gprm_y = deltaR*svprm_y + deltaRprm_y*sv
Hwrpt2fprm_y = sn*sqrtdeltaRprm_y + snprm_y*sqrtdeltaR
Hwrpt2eprm_y = Hwrpt2f*pvrprm_y + Hwrpt2fprm_y*pvr
Hwrpt2dprm_y = Hwrpt2g*pnsqprm_y + Hwrpt2gprm_y*pnsq
Hwrpt2cprm_y = Hwrpt2e*pnprm_y + Hwrpt2eprm_y*pn
Hwrpt2bprm_y = expMUsqsqrtQplusQ*svprm_y + expMUsqsqrtQplusQprm_y*sv
Hwrpt2aprm_y = xi2*(Hwrpt2bprm_y + Hwrpt2cprm_y - Hwrpt2dprm_y) + xi2prm_y*(Hwrpt2b + Hwrpt2c - Hwrpt2d)
Hwrpt2prm_y = Hwrpt2a*deltaTprm_y + Hwrpt2aprm_y*deltaT
Hwrpt1bprm_y = invtwoB1psqrtQsqrtQ*invxi2prm_y + invtwoB1psqrtQsqrtQprm_y*invxi2
Hwrpt1aprm_y = Hwrpt1b*sqrtdeltaRprm_y + Hwrpt1bprm_y*sqrtdeltaR
Hwrpt1prm_y = Hwrpt1a*invexpMUcubinvexpnuprm_y + Hwrpt1aprm_y*invexpMUcubinvexpnu
Hwrprm_y = Hwrpt1*(Hwrpt2prm_y - Hwrpt3prm_y + Hwrpt4prm_y) + Hwrpt1prm_y*(Hwrpt2 - Hwrpt3 + Hwrpt4)
Hwcospt9prm_y = pxir*sxiprm_y + pxirprm_y*sxi
Hwcospt8prm_y = pvr*svprm_y + pvrprm_y*sv
Hwcospt7prm_y = B*Hwcospt8prm_y + Bprm_y*Hwcospt8 - Hwcospt9*expMUexpnuprm_y - Hwcospt9prm_y*expMUexpnu
Hwcospt6prm_y = Hwcospt7*sqrtdeltaRprm_y + Hwcospt7prm_y*sqrtdeltaR
Hwcospt5prm_y = -expMUsqsqrtQplusQ*xi2prm_y - expMUsqsqrtQplusQprm_y*xi2 + pvrsqprm_y
Hwcospt4prm_y = Hwcospt6*pnprm_y + Hwcospt6prm_y*pn
Hwcospt3prm_y = Hwcospt5*deltaTprm_y + Hwcospt5prm_y*deltaT - expMUsqexpnusq*pxirsqprm_y - expMUsqexpnusqprm_y*pxirsq
Hwcospt2prm_y = -B*Hwcospt4prm_y - Bprm_y*Hwcospt4 + Hwcospt3*snprm_y + Hwcospt3prm_y*sn
Hwcospt1prm_y = Hwcospt2*invexpMUcubinvexpnuprm_y + Hwcospt2prm_y*invexpMUcubinvexpnu
Hwcosprm_y = Hwcospt1*invtwoB1psqrtQsqrtQprm_y + Hwcospt1prm_y*invtwoB1psqrtQsqrtQ
deltaTsqrtQprm_y = deltaT*sqrtQprm_y + deltaTprm_y*sqrtQ
invdeltatTsqrtQprm_y = -deltaTsqrtQprm_y/deltaTsqrtQ**2
HSOLpt5prm_y = pxir*(-Bprm_y + expMUexpnuprm_y) + pxirprm_y*(-B + expMUexpnu)
HSOLpt4prm_y = HSOLpt5*invexpMUprm_y + HSOLpt5prm_y*invexpMU
HSOLpt3prm_y = HSOLpt4*expnusqprm_y + HSOLpt4prm_y*expnusq
HSOLpt2prm_y = HSOLpt3*s3prm_y + HSOLpt3prm_y*s3
HSOLpt1prm_y = HSOLpt2*invxi2prm_y + HSOLpt2prm_y*invxi2
HSOLprm_y = HSOLpt1*invdeltatTsqrtQprm_y + HSOLpt1prm_y*invdeltatTsqrtQ
deltaTsqrtQplusQprm_y = deltaT*(Qprm_y + sqrtQprm_y) + deltaTprm_y*(Q + sqrtQ)
invdeltaTsqrtQplusQprm_y = -deltaTsqrtQplusQprm_y/deltaTsqrtQplusQ**2
HSONLmult2prm_y = invdeltaTsqrtQplusQ*invxi2prm_y + invdeltaTsqrtQplusQprm_y*invxi2
HSONLmultprm_y = HSONLmult2*expnuinvexpMU2prm_y + HSONLmult2prm_y*expnuinvexpMU2
HSONLpt1bprm_y = pn*xi2prm_y + pnprm_y*xi2
HSONLpt1aprm_y = HSONLpt1b*(-mucosprm_y + nucosprm_y) + HSONLpt1bprm_y*(-mucos + nucos) + mur*pvrprm_y + murprm_y*pvr - nur*pvrprm_y - nurprm_y*pvr
HSONLpt1prm_y = HSONLpt1a*sqrtQprm_y + HSONLpt1aprm_y*sqrtQ - HSONLpt1b*mucosprm_y - HSONLpt1bprm_y*mucos + mur*pvrprm_y + murprm_y*pvr
HSONLpt2dprm_y = nur*pxirprm_y + nurprm_y*pxir
HSONLpt2cprm_y = HSONLpt2d*oneplus2sqrtQprm_y + HSONLpt2dprm_y*oneplus2sqrtQ
HSONLpt2bprm_y = B*sxiprm_y + Bprm_y*sxi
HSONLpt2aprm_y = HSONLpt2c*expMUexpnuprm_y + HSONLpt2cprm_y*expMUexpnu
HSONLpt2prm_y = HSONLpt1*HSONLpt2bprm_y + HSONLpt1prm_y*HSONLpt2b + HSONLpt2a*svprm_y + HSONLpt2aprm_y*sv
HSONLpt3cprm_y = pxir*svprm_y + pxirprm_y*sv
HSONLpt3bprm_y = HSONLpt3c*oneplus1sqrtQprm_y + HSONLpt3cprm_y*oneplus1sqrtQ
HSONLpt3aprm_y = HSONLpt3b*expMUexpnuprm_y + HSONLpt3bprm_y*expMUexpnu
HSONLpt3prm_y = B*HSONLpt2prm_y - BR*HSONLpt3aprm_y - BRprm_y*HSONLpt3a + Bprm_y*HSONLpt2
HSONLpt4eprm_y = sn*xi2prm_y + snprm_y*xi2
HSONLpt4dprm_y = HSONLpt4e*oneplus2sqrtQprm_y + HSONLpt4eprm_y*oneplus2sqrtQ
HSONLpt4cprm_y = HSONLpt4d*pxirprm_y + HSONLpt4dprm_y*pxir
HSONLpt4bprm_y = HSONLpt4c*nucosprm_y + HSONLpt4cprm_y*nucos
HSONLpt4aprm_y = HSONLpt4b*expMUexpnuprm_y + HSONLpt4bprm_y*expMUexpnu
HSONLpt4prm_y = -B*HSONLpt4aprm_y - Bprm_y*HSONLpt4a + HSONLpt3*sqrtdeltaRprm_y + HSONLpt3prm_y*sqrtdeltaR
HSONLprm_y = HSONLmult*HSONLpt4prm_y + HSONLmultprm_y*HSONLpt4
Hsprm_y = HSOLprm_y + HSONLprm_y + Hwcos*wcosprm_y + Hwcosprm_y*wcos + Hwr*wrprm_y + Hwrprm_y*wr + s3*wprm_y + s3prm_y*w
Hsspt1prm_y = 3*sn*snprm_y - sx*sxprm_y - sy*syprm_y - sz*szprm_y
Hssprm_y = Hsspt1*u3prm_y + Hsspt1prm_y*u3
Hpt1prm_y = etau4prm_y*(s1dots1 + s2dots2)
Hprm_y = Hnsprm_y + Hpt1prm_y*dheffSSv2 + Hsprm_y + Hssprm_y
Hrealprm_y = Hprm_y*eta*sp.sign(H)/sp.sqrt(2*eta*(sp.Abs(H) - 1) + 1)
r2prm_z = 2*z
rprm_z = r2prm_z/(2*sp.sqrt(r2))
uprm_z = -rprm_z/r**2
u2prm_z = 2*u*uprm_z
u3prm_z = u*u2prm_z + u2*uprm_z
u4prm_z = 2*u2*u2prm_z
u5prm_z = u*u4prm_z + u4*uprm_z
etau3prm_z = eta*u3prm_z
etau4prm_z = eta*u4prm_z
nxprm_z = uprm_z*x
nyprm_z = uprm_z*y
nzprm_z = u + uprm_z*z
costhetaprm_z = e3USCOREx*nxprm_z + e3USCOREy*nyprm_z + e3USCOREz*nzprm_z
xi2prm_z = -2*costheta*costhetaprm_z
xiUSCORExprm_z = e3USCOREy*nzprm_z - e3USCOREz*nyprm_z
xiUSCOREyprm_z = -e3USCOREx*nzprm_z + e3USCOREz*nxprm_z
xiUSCOREzprm_z = e3USCOREx*nyprm_z - e3USCOREy*nxprm_z
vxprm_z = ny*xiUSCOREzprm_z + nyprm_z*xiUSCOREz - nz*xiUSCOREyprm_z - nzprm_z*xiUSCOREy
vyprm_z = -nx*xiUSCOREzprm_z - nxprm_z*xiUSCOREz + nz*xiUSCORExprm_z + nzprm_z*xiUSCOREx
vzprm_z = nx*xiUSCOREyprm_z + nxprm_z*xiUSCOREy - ny*xiUSCORExprm_z - nyprm_z*xiUSCOREx
w2prm_z = r2prm_z
rho2prm_z = 2*a2*costheta*costhetaprm_z + r2prm_z
bulkprm_z = a2*u2prm_z + 2*invm1PlusetaKK*uprm_z
loguprm_z = uprm_z/u
logargprm_z = k1*uprm_z + k2*u2prm_z + k3*u3prm_z + k4*u4prm_z + k5*u5prm_z + k5l*logu*u5prm_z + k5l*loguprm_z*u5
onepluslogargprm_z = logargprm_z
invonepluslogargprm_z = -onepluslogargprm_z/onepluslogarg**2
logTermsprm_z = eta*onepluslogargprm_z*sp.sign(onepluslogarg)/sp.Abs(onepluslogarg)
deltaUprm_z = (bulk*logTermsprm_z + bulkprm_z*logTerms)*sp.sign(bulk*logTerms)
deltaTprm_z = deltaU*r2prm_z + deltaUprm_z*r2
deltaUUSCOREupt7prm_z = k5l*loguprm_z
deltaUUSCOREupt6prm_z = 5*deltaUUSCOREupt7*uprm_z + 5*deltaUUSCOREupt7prm_z*u
deltaUUSCOREupt5prm_z = deltaUUSCOREupt6*uprm_z + deltaUUSCOREupt6prm_z*u
deltaUUSCOREupt4prm_z = deltaUUSCOREupt5*uprm_z + deltaUUSCOREupt5prm_z*u
deltaUUSCOREupt3prm_z = deltaUUSCOREupt4*uprm_z + deltaUUSCOREupt4prm_z*u
deltaUUSCOREupt2prm_z = a2*uprm_z
deltaUUSCOREupt1prm_z = bulk*deltaUUSCOREupt3prm_z*eta + bulkprm_z*deltaUUSCOREupt3*eta
deltaUUSCOREuprm_z = deltaUUSCOREupt1*invonepluslogargprm_z + deltaUUSCOREupt1prm_z*invonepluslogarg + 2*deltaUUSCOREupt2*logTermsprm_z + 2*deltaUUSCOREupt2prm_z*logTerms
deltaTUSCORErprm_z = 2*deltaU*rprm_z - deltaUUSCOREuprm_z + 2*deltaUprm_z*r
Lambprm_z = (a2*deltaT*xi2prm_z + a2*deltaTprm_z*xi2 - 2*w2*w2prm_z)*sp.sign(a2*deltaT*xi2 - w2**2)
rho2xi2Lambprm_z = Lamb*rho2*xi2prm_z + Lamb*rho2prm_z*xi2 + Lambprm_z*rho2*xi2
invrho2xi2Lambprm_z = -rho2xi2Lambprm_z/rho2xi2Lamb**2
invrho2prm_z = -rho2prm_z/rho2**2
invxi2prm_z = -xi2prm_z/xi2**2
invLambprm_z = -Lambprm_z/Lamb**2
invLambsqprm_z = 2*invLamb*invLambprm_z
rho2invLambprm_z = invLamb*rho2prm_z + invLambprm_z*rho2
expnuprm_z = sp.sqrt(deltaT*rho2invLamb)*(deltaT*rho2invLambprm_z/2 + deltaTprm_z*rho2invLamb/2)/(deltaT*rho2invLamb)
expMUprm_z = rho2prm_z/(2*sp.sqrt(rho2))
expMUexpnuprm_z = expMU*expnuprm_z + expMUprm_z*expnu
expMUsqprm_z = 2*expMU*expMUprm_z
expnusqprm_z = 2*expnu*expnuprm_z
expMUsqexpnusqprm_z = expMUsq*expnusqprm_z + expMUsqprm_z*expnusq
invexpnuexpMUprm_z = -expMUexpnuprm_z/expMUexpnu**2
invexpMUprm_z = expnu*invexpnuexpMUprm_z + expnuprm_z*invexpnuexpMU
invexpMUsqprm_z = 2*invexpMU*invexpMUprm_z
expnuinvexpMU2prm_z = expnu*invexpMUsqprm_z + expnuprm_z*invexpMUsq
invexpMUcubinvexpnuprm_z = invexpMUsq*invexpnuexpMUprm_z + invexpMUsqprm_z*invexpnuexpMU
DDprm_z = (6*eta*u2prm_z + etau3prm_z*(52 - 6*eta))/(6*eta*u2 + etau3*(52 - 6*eta) + 1)
deltaRprm_z = DD*deltaTprm_z + DDprm_z*deltaT
wwprm_z = a*a2*b3*eta*uprm_z + a*bb3*eta*uprm_z + 2*a*rprm_z
Bprm_z = deltaTprm_z/(2*sp.sqrt(deltaT))
sqrtdeltaTprm_z = Bprm_z
sqrtdeltaRprm_z = deltaRprm_z/(2*sp.sqrt(deltaR))
deltaTsqrtdeltaRprm_z = deltaT*sqrtdeltaRprm_z + deltaTprm_z*sqrtdeltaR
sqrtdeltaTdeltaTsqrtdeltaRprm_z = deltaTsqrtdeltaR*sqrtdeltaTprm_z + deltaTsqrtdeltaRprm_z*sqrtdeltaT
invdeltaTsqrtdeltaTsqrtdeltaRprm_z = -1.0*sqrtdeltaTdeltaTsqrtdeltaRprm_z/sqrtdeltaTdeltaTsqrtdeltaR**2
invdeltaTprm_z = invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaR*sqrtdeltaTprm_z + invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaRprm_z*sqrtdeltaT + invdeltaTsqrtdeltaTsqrtdeltaRprm_z*sqrtdeltaR*sqrtdeltaT
invsqrtdeltaTprm_z = deltaTsqrtdeltaR*invdeltaTsqrtdeltaTsqrtdeltaRprm_z + deltaTsqrtdeltaRprm_z*invdeltaTsqrtdeltaTsqrtdeltaR
invsqrtdeltaRprm_z = deltaT*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaTprm_z + deltaT*invdeltaTsqrtdeltaTsqrtdeltaRprm_z*sqrtdeltaT + deltaTprm_z*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaT
wprm_z = invLamb*wwprm_z + invLambprm_z*ww
LambUSCORErprm_z = -a2*deltaTUSCOREr*xi2prm_z - a2*deltaTUSCORErprm_z*xi2 + 4*r*w2prm_z + 4*rprm_z*w2
wwUSCORErprm_z = -a*a2*b3*eta*u2prm_z - a*bb3*eta*u2prm_z
BRprm_z = invsqrtdeltaT*(-deltaT*invsqrtdeltaRprm_z + deltaTUSCORErprm_z/2 - deltaTprm_z*invsqrtdeltaR) + invsqrtdeltaTprm_z*(-deltaT*invsqrtdeltaR + deltaTUSCOREr/2)
wrprm_z = invLambsq*(Lamb*wwUSCORErprm_z - LambUSCOREr*wwprm_z - LambUSCORErprm_z*ww + Lambprm_z*wwUSCOREr) + invLambsqprm_z*(Lamb*wwUSCOREr - LambUSCOREr*ww)
nurpt2prm_z = w2*(-4.0*deltaT*rprm_z + deltaTUSCOREr*w2prm_z + deltaTUSCORErprm_z*w2 - 4.0*deltaTprm_z*r) + w2prm_z*(-4.0*deltaT*r + deltaTUSCOREr*w2)
nurpt1prm_z = invdeltaT*nurpt2prm_z + invdeltaTprm_z*nurpt2
nurprm_z = invLamb*nurpt1prm_z/2 + invLambprm_z*nurpt1/2 + invrho2*rprm_z + invrho2prm_z*r
murprm_z = invrho2*rprm_z + invrho2prm_z*r - invsqrtdeltaRprm_z
a2costhetaprm_z = a2*costhetaprm_z
wcospt2prm_z = deltaT*wwprm_z + deltaTprm_z*ww
wcospt1prm_z = invLambsq*wcospt2prm_z + invLambsqprm_z*wcospt2
wcosprm_z = -2*a2costheta*wcospt1prm_z - 2*a2costhetaprm_z*wcospt1
nucospt3prm_z = invLamb*invrho2prm_z + invLambprm_z*invrho2
nucospt2prm_z = nucospt3*w2prm_z + nucospt3prm_z*w2
nucospt1prm_z = a2costheta*nucospt2prm_z + a2costhetaprm_z*nucospt2
nucosprm_z = nucospt1*(-deltaTprm_z + w2prm_z) + nucospt1prm_z*(-deltaT + w2)
mucosprm_z = a2costheta*invrho2prm_z + a2costhetaprm_z*invrho2
etaover12rprm_z = eta*uprm_z/12
csiprm_z = (deltaR*deltaTprm_z + deltaRprm_z*deltaT)*sp.sign(deltaR*deltaT)/(2*w2*sp.sqrt(sp.Abs(deltaR*deltaT))) - w2prm_z*sp.sqrt(sp.Abs(deltaR*deltaT))/w2**2
csi1prm_z = csiprm_z*(1 - sp.Abs(tortoise - 1))
csi2prm_z = csiprm_z*(1/2 - 0.5*sp.sign(1.5 - tortoise))
prTprm_z = csi2*(nxprm_z*px + nyprm_z*py + nzprm_z*pz) + csi2prm_z*(nx*px + ny*py + nz*pz)
prTtimesoneminuscsi1invprm_z = prTprm_z*(1 - 1/csi1) + csi1prm_z*prT/csi1**2
tmppxprm_z = -nx*prTtimesoneminuscsi1invprm_z - nxprm_z*prTtimesoneminuscsi1inv
tmppyprm_z = -ny*prTtimesoneminuscsi1invprm_z - nyprm_z*prTtimesoneminuscsi1inv
tmppzprm_z = -nz*prTtimesoneminuscsi1invprm_z - nzprm_z*prTtimesoneminuscsi1inv
pxirprm_z = r*(tmppx*xiUSCORExprm_z + tmppxprm_z*xiUSCOREx + tmppy*xiUSCOREyprm_z + tmppyprm_z*xiUSCOREy + tmppz*xiUSCOREzprm_z + tmppzprm_z*xiUSCOREz) + rprm_z*(tmppx*xiUSCOREx + tmppy*xiUSCOREy + tmppz*xiUSCOREz)
pvrprm_z = r*(tmppx*vxprm_z + tmppxprm_z*vx + tmppy*vyprm_z + tmppyprm_z*vy + tmppz*vzprm_z + tmppzprm_z*vz) + rprm_z*(tmppx*vx + tmppy*vy + tmppz*vz)
pvrsqprm_z = 2*pvr*pvrprm_z
pnprm_z = nx*tmppxprm_z + nxprm_z*tmppx + ny*tmppyprm_z + nyprm_z*tmppy + nz*tmppzprm_z + nzprm_z*tmppz
pnsqprm_z = 2*pn*pnprm_z
prprm_z = pnprm_z
prsqprm_z = 2*pr*prprm_z
pfprm_z = pxirprm_z
pxirsqprm_z = 2*pxir*pxirprm_z
ptheta2prm_z = invxi2*pvrsqprm_z + invxi2prm_z*pvrsq
prT4prm_z = 4*prT**3*prTprm_z
Hnspt7prm_z = deltaR*invrho2prm_z + deltaRprm_z*invrho2
Hnspt6prm_z = invxi2*rho2invLambprm_z + invxi2prm_z*rho2invLamb
Hnspt5prm_z = qq*u2prm_z
Hnspt4prm_z = Hnspt5*prT4prm_z + Hnspt5prm_z*prT4 + 2*Hnspt6*pf*pfprm_z + Hnspt6prm_z*pf**2 + Hnspt7*prsqprm_z + Hnspt7prm_z*prsq + invrho2*ptheta2prm_z + invrho2prm_z*ptheta2
Hnspt3prm_z = Hnspt4*deltaTprm_z + Hnspt4prm_z*deltaT
Hnspt2prm_z = Hnspt3*rho2prm_z + Hnspt3prm_z*rho2
Hnspt1prm_z = pf*wwprm_z + pfprm_z*ww
Hnsprm_z = Hnspt1*invLambprm_z + Hnspt1prm_z*invLamb + sp.sqrt(Hnspt2*invLamb)*(Hnspt2*invLambprm_z/2 + Hnspt2prm_z*invLamb/2)/(Hnspt2*invLamb)
Qpt3prm_z = deltaR*invrho2prm_z + deltaRprm_z*invrho2
Qpt2prm_z = invxi2*rho2invLambprm_z + invxi2prm_z*rho2invLamb
Qpt1prm_z = invrho2*invxi2prm_z + invrho2prm_z*invxi2
Qprm_z = Qpt1*pvrsqprm_z + Qpt1prm_z*pvrsq + Qpt2*pxirsqprm_z + Qpt2prm_z*pxirsq + Qpt3*pnsqprm_z + Qpt3prm_z*pnsq
pn2prm_z = deltaR*invrho2*prsqprm_z + deltaR*invrho2prm_z*prsq + deltaRprm_z*invrho2*prsq
ppprm_z = Qprm_z
sKerrmultfactprm_z = r*(-36*pn2prm_z + 3*ppprm_z) + rprm_z*(-36*pn2 + 3*pp)
sStarmultfactprm_z = r*(-30*pn2prm_z + 4*ppprm_z) + rprm_z*(-30*pn2 + 4*pp)
deltaSigmaStarUSCOREx1prm_z = etaover12r*(sKerrUSCOREx*sKerrmultfactprm_z + sStarUSCOREx*sStarmultfactprm_z) + etaover12rprm_z*(sKerrUSCOREx*sKerrmultfact + sStarUSCOREx*sStarmultfact)
deltaSigmaStarUSCOREy1prm_z = etaover12r*(sKerrUSCOREy*sKerrmultfactprm_z + sStarUSCOREy*sStarmultfactprm_z) + etaover12rprm_z*(sKerrUSCOREy*sKerrmultfact + sStarUSCOREy*sStarmultfact)
deltaSigmaStarUSCOREz1prm_z = etaover12r*(sKerrUSCOREz*sKerrmultfactprm_z + sStarUSCOREz*sStarmultfactprm_z) + etaover12rprm_z*(sKerrUSCOREz*sKerrmultfact + sStarUSCOREz*sStarmultfact)
pn2ppprm_z = pn2*ppprm_z + pn2prm_z*pp
pp2prm_z = 2*pp*ppprm_z
pn2u2prm_z = pn2*u2prm_z + pn2prm_z*u2
ppu2prm_z = pp*u2prm_z + ppprm_z*u2
pn2ppu2prm_z = pn2pp*u2prm_z + pn2ppprm_z*u2
sMultiplier1pt6prm_z = -720*pn2*pn2prm_z + 126*pn2ppprm_z + 3*pp2prm_z
sMultiplier1pt5prm_z = -96*pn2ppprm_z + 23*pp2prm_z
sMultiplier1pt4prm_z = 324*pn2prm_z - 120*ppprm_z + r*sMultiplier1pt6prm_z + rprm_z*sMultiplier1pt6
sMultiplier1pt3prm_z = -282*pn2prm_z + 206*ppprm_z + r*sMultiplier1pt5prm_z + rprm_z*sMultiplier1pt5
sMultiplier1pt2prm_z = r*sMultiplier1pt4prm_z + rprm_z*sMultiplier1pt4
sMultiplier1pt1prm_z = eta*sMultiplier1pt2prm_z + r*sMultiplier1pt3prm_z + rprm_z*sMultiplier1pt3
sMultiplier1prm_z = -eta*sMultiplier1pt1*u2prm_z/72 - eta*sMultiplier1pt1prm_z*u2/72
sMultiplier2pt6prm_z = 45*pn2*pn2u2prm_z/8 - 13*pn2ppu2prm_z/8 + 45*pn2prm_z*pn2u2/8
sMultiplier2pt5prm_z = pn2ppu2prm_z/4 - 5*pp2*u2prm_z/16 - 5*pp2prm_z*u2/16
sMultiplier2pt4prm_z = -49*pn2u2prm_z/8 + 17*ppu2prm_z/12 + r*sMultiplier2pt6prm_z + rprm_z*sMultiplier2pt6
sMultiplier2pt3prm_z = -2*pn2u2prm_z/3 - 109*ppu2prm_z/36 + r*sMultiplier2pt5prm_z + rprm_z*sMultiplier2pt5
sMultiplier2pt2prm_z = r*sMultiplier2pt4prm_z + rprm_z*sMultiplier2pt4 - 7*u2prm_z/3
sMultiplier2pt1prm_z = eta*sMultiplier2pt2prm_z + r*sMultiplier2pt3prm_z + rprm_z*sMultiplier2pt3 - 56*u2prm_z/9
sMultiplier2prm_z = eta*sMultiplier2pt1prm_z
deltaSigmaStarUSCOREx2prm_z = deltaSigmaStarUSCOREx1prm_z + sMultiplier1prm_z*sigmaStar0 + sMultiplier2prm_z*sigmaKerr0
deltaSigmaStarUSCOREy2prm_z = deltaSigmaStarUSCOREy1prm_z + sMultiplier1prm_z*sigmaStar1 + sMultiplier2prm_z*sigmaKerr1
deltaSigmaStarUSCOREz2prm_z = deltaSigmaStarUSCOREz1prm_z + sMultiplier1prm_z*sigmaStar2 + sMultiplier2prm_z*sigmaKerr2
deltaSigmaStarUSCORExprm_z = d1v2*etau3prm_z*sigmaKerr0 + deltaSigmaStarUSCOREx2prm_z
deltaSigmaStarUSCOREyprm_z = d1v2*etau3prm_z*sigmaKerr1 + deltaSigmaStarUSCOREy2prm_z
deltaSigmaStarUSCOREzprm_z = d1v2*etau3prm_z*sigmaKerr2 + deltaSigmaStarUSCOREz2prm_z
sxprm_z = deltaSigmaStarUSCORExprm_z
syprm_z = deltaSigmaStarUSCOREyprm_z
szprm_z = deltaSigmaStarUSCOREzprm_z
sxiprm_z = sx*xiUSCORExprm_z + sxprm_z*xiUSCOREx + sy*xiUSCOREyprm_z + syprm_z*xiUSCOREy + sz*xiUSCOREzprm_z + szprm_z*xiUSCOREz
svprm_z = sx*vxprm_z + sxprm_z*vx + sy*vyprm_z + syprm_z*vy + sz*vzprm_z + szprm_z*vz
snprm_z = nx*sxprm_z + nxprm_z*sx + ny*syprm_z + nyprm_z*sy + nz*szprm_z + nzprm_z*sz
s3prm_z = e3USCOREx*sxprm_z + e3USCOREy*syprm_z + e3USCOREz*szprm_z
sqrtQprm_z = Qprm_z/(2*sp.sqrt(Q))
oneplus2sqrtQprm_z = 2*sqrtQprm_z
oneplus1sqrtQprm_z = oneplus2sqrtQprm_z - sqrtQprm_z
twoB1psqrtQsqrtQprm_z = 2*B*oneplus1sqrtQ*sqrtQprm_z + 2*B*oneplus1sqrtQprm_z*sqrtQ + 2*Bprm_z*oneplus1sqrtQ*sqrtQ
invtwoB1psqrtQsqrtQprm_z = -twoB1psqrtQsqrtQprm_z/twoB1psqrtQsqrtQ**2
expMUsqsqrtQplusQprm_z = expMUsq*(Qprm_z + sqrtQprm_z) + expMUsqprm_z*(Q + sqrtQ)
Hwrpt4aprm_z = pxirsq*svprm_z + pxirsqprm_z*sv
Hwrpt4prm_z = Hwrpt4a*expMUsqexpnusqprm_z + Hwrpt4aprm_z*expMUsqexpnusq
Hwrpt3cprm_z = pxir*sxiprm_z + pxirprm_z*sxi
Hwrpt3bprm_z = Hwrpt3c*pvrprm_z + Hwrpt3cprm_z*pvr
Hwrpt3aprm_z = Hwrpt3b*expMUexpnuprm_z + Hwrpt3bprm_z*expMUexpnu
Hwrpt3prm_z = B*Hwrpt3aprm_z + Bprm_z*Hwrpt3a
Hwrpt2gprm_z = deltaR*svprm_z + deltaRprm_z*sv
Hwrpt2fprm_z = sn*sqrtdeltaRprm_z + snprm_z*sqrtdeltaR
Hwrpt2eprm_z = Hwrpt2f*pvrprm_z + Hwrpt2fprm_z*pvr
Hwrpt2dprm_z = Hwrpt2g*pnsqprm_z + Hwrpt2gprm_z*pnsq
Hwrpt2cprm_z = Hwrpt2e*pnprm_z + Hwrpt2eprm_z*pn
Hwrpt2bprm_z = expMUsqsqrtQplusQ*svprm_z + expMUsqsqrtQplusQprm_z*sv
Hwrpt2aprm_z = xi2*(Hwrpt2bprm_z + Hwrpt2cprm_z - Hwrpt2dprm_z) + xi2prm_z*(Hwrpt2b + Hwrpt2c - Hwrpt2d)
Hwrpt2prm_z = Hwrpt2a*deltaTprm_z + Hwrpt2aprm_z*deltaT
Hwrpt1bprm_z = invtwoB1psqrtQsqrtQ*invxi2prm_z + invtwoB1psqrtQsqrtQprm_z*invxi2
Hwrpt1aprm_z = Hwrpt1b*sqrtdeltaRprm_z + Hwrpt1bprm_z*sqrtdeltaR
Hwrpt1prm_z = Hwrpt1a*invexpMUcubinvexpnuprm_z + Hwrpt1aprm_z*invexpMUcubinvexpnu
Hwrprm_z = Hwrpt1*(Hwrpt2prm_z - Hwrpt3prm_z + Hwrpt4prm_z) + Hwrpt1prm_z*(Hwrpt2 - Hwrpt3 + Hwrpt4)
Hwcospt9prm_z = pxir*sxiprm_z + pxirprm_z*sxi
Hwcospt8prm_z = pvr*svprm_z + pvrprm_z*sv
Hwcospt7prm_z = B*Hwcospt8prm_z + Bprm_z*Hwcospt8 - Hwcospt9*expMUexpnuprm_z - Hwcospt9prm_z*expMUexpnu
Hwcospt6prm_z = Hwcospt7*sqrtdeltaRprm_z + Hwcospt7prm_z*sqrtdeltaR
Hwcospt5prm_z = -expMUsqsqrtQplusQ*xi2prm_z - expMUsqsqrtQplusQprm_z*xi2 + pvrsqprm_z
Hwcospt4prm_z = Hwcospt6*pnprm_z + Hwcospt6prm_z*pn
Hwcospt3prm_z = Hwcospt5*deltaTprm_z + Hwcospt5prm_z*deltaT - expMUsqexpnusq*pxirsqprm_z - expMUsqexpnusqprm_z*pxirsq
Hwcospt2prm_z = -B*Hwcospt4prm_z - Bprm_z*Hwcospt4 + Hwcospt3*snprm_z + Hwcospt3prm_z*sn
Hwcospt1prm_z = Hwcospt2*invexpMUcubinvexpnuprm_z + Hwcospt2prm_z*invexpMUcubinvexpnu
Hwcosprm_z = Hwcospt1*invtwoB1psqrtQsqrtQprm_z + Hwcospt1prm_z*invtwoB1psqrtQsqrtQ
deltaTsqrtQprm_z = deltaT*sqrtQprm_z + deltaTprm_z*sqrtQ
invdeltatTsqrtQprm_z = -deltaTsqrtQprm_z/deltaTsqrtQ**2
HSOLpt5prm_z = pxir*(-Bprm_z + expMUexpnuprm_z) + pxirprm_z*(-B + expMUexpnu)
HSOLpt4prm_z = HSOLpt5*invexpMUprm_z + HSOLpt5prm_z*invexpMU
HSOLpt3prm_z = HSOLpt4*expnusqprm_z + HSOLpt4prm_z*expnusq
HSOLpt2prm_z = HSOLpt3*s3prm_z + HSOLpt3prm_z*s3
HSOLpt1prm_z = HSOLpt2*invxi2prm_z + HSOLpt2prm_z*invxi2
HSOLprm_z = HSOLpt1*invdeltatTsqrtQprm_z + HSOLpt1prm_z*invdeltatTsqrtQ
deltaTsqrtQplusQprm_z = deltaT*(Qprm_z + sqrtQprm_z) + deltaTprm_z*(Q + sqrtQ)
invdeltaTsqrtQplusQprm_z = -deltaTsqrtQplusQprm_z/deltaTsqrtQplusQ**2
HSONLmult2prm_z = invdeltaTsqrtQplusQ*invxi2prm_z + invdeltaTsqrtQplusQprm_z*invxi2
HSONLmultprm_z = HSONLmult2*expnuinvexpMU2prm_z + HSONLmult2prm_z*expnuinvexpMU2
HSONLpt1bprm_z = pn*xi2prm_z + pnprm_z*xi2
HSONLpt1aprm_z = HSONLpt1b*(-mucosprm_z + nucosprm_z) + HSONLpt1bprm_z*(-mucos + nucos) + mur*pvrprm_z + murprm_z*pvr - nur*pvrprm_z - nurprm_z*pvr
HSONLpt1prm_z = HSONLpt1a*sqrtQprm_z + HSONLpt1aprm_z*sqrtQ - HSONLpt1b*mucosprm_z - HSONLpt1bprm_z*mucos + mur*pvrprm_z + murprm_z*pvr
HSONLpt2dprm_z = nur*pxirprm_z + nurprm_z*pxir
HSONLpt2cprm_z = HSONLpt2d*oneplus2sqrtQprm_z + HSONLpt2dprm_z*oneplus2sqrtQ
HSONLpt2bprm_z = B*sxiprm_z + Bprm_z*sxi
HSONLpt2aprm_z = HSONLpt2c*expMUexpnuprm_z + HSONLpt2cprm_z*expMUexpnu
HSONLpt2prm_z = HSONLpt1*HSONLpt2bprm_z + HSONLpt1prm_z*HSONLpt2b + HSONLpt2a*svprm_z + HSONLpt2aprm_z*sv
HSONLpt3cprm_z = pxir*svprm_z + pxirprm_z*sv
HSONLpt3bprm_z = HSONLpt3c*oneplus1sqrtQprm_z + HSONLpt3cprm_z*oneplus1sqrtQ
HSONLpt3aprm_z = HSONLpt3b*expMUexpnuprm_z + HSONLpt3bprm_z*expMUexpnu
HSONLpt3prm_z = B*HSONLpt2prm_z - BR*HSONLpt3aprm_z - BRprm_z*HSONLpt3a + Bprm_z*HSONLpt2
HSONLpt4eprm_z = sn*xi2prm_z + snprm_z*xi2
HSONLpt4dprm_z = HSONLpt4e*oneplus2sqrtQprm_z + HSONLpt4eprm_z*oneplus2sqrtQ
HSONLpt4cprm_z = HSONLpt4d*pxirprm_z + HSONLpt4dprm_z*pxir
HSONLpt4bprm_z = HSONLpt4c*nucosprm_z + HSONLpt4cprm_z*nucos
HSONLpt4aprm_z = HSONLpt4b*expMUexpnuprm_z + HSONLpt4bprm_z*expMUexpnu
HSONLpt4prm_z = -B*HSONLpt4aprm_z - Bprm_z*HSONLpt4a + HSONLpt3*sqrtdeltaRprm_z + HSONLpt3prm_z*sqrtdeltaR
HSONLprm_z = HSONLmult*HSONLpt4prm_z + HSONLmultprm_z*HSONLpt4
Hsprm_z = HSOLprm_z + HSONLprm_z + Hwcos*wcosprm_z + Hwcosprm_z*wcos + Hwr*wrprm_z + Hwrprm_z*wr + s3*wprm_z + s3prm_z*w
Hsspt1prm_z = 3*sn*snprm_z - sx*sxprm_z - sy*syprm_z - sz*szprm_z
Hssprm_z = Hsspt1*u3prm_z + Hsspt1prm_z*u3
Hpt1prm_z = etau4prm_z*(s1dots1 + s2dots2)
Hprm_z = Hnsprm_z + Hpt1prm_z*dheffSSv2 + Hsprm_z + Hssprm_z
Hrealprm_z = Hprm_z*eta*sp.sign(H)/sp.sqrt(2*eta*(sp.Abs(H) - 1) + 1)
prTprm_px = csi2*nx
prTtimesoneminuscsi1invprm_px = prTprm_px*(1 - 1/csi1)
tmppxprm_px = -nx*prTtimesoneminuscsi1invprm_px + 1
tmppyprm_px = -ny*prTtimesoneminuscsi1invprm_px
tmppzprm_px = -nz*prTtimesoneminuscsi1invprm_px
pxirprm_px = r*(tmppxprm_px*xiUSCOREx + tmppyprm_px*xiUSCOREy + tmppzprm_px*xiUSCOREz)
pvrprm_px = r*(tmppxprm_px*vx + tmppyprm_px*vy + tmppzprm_px*vz)
pvrsqprm_px = 2*pvr*pvrprm_px
pnprm_px = nx*tmppxprm_px + ny*tmppyprm_px + nz*tmppzprm_px
pnsqprm_px = 2*pn*pnprm_px
prprm_px = pnprm_px
prsqprm_px = 2*pr*prprm_px
pfprm_px = pxirprm_px
pxirsqprm_px = 2*pxir*pxirprm_px
ptheta2prm_px = invxi2*pvrsqprm_px
prT4prm_px = 4*prT**3*prTprm_px
Hnspt4prm_px = Hnspt5*prT4prm_px + 2*Hnspt6*pf*pfprm_px + Hnspt7*prsqprm_px + invrho2*ptheta2prm_px
Hnspt3prm_px = Hnspt4prm_px*deltaT
Hnspt2prm_px = Hnspt3prm_px*rho2
Hnspt1prm_px = pfprm_px*ww
Hnsprm_px = Hnspt1prm_px*invLamb + Hnspt2prm_px*sp.sqrt(Hnspt2*invLamb)/(2*Hnspt2)
Qprm_px = Qpt1*pvrsqprm_px + Qpt2*pxirsqprm_px + Qpt3*pnsqprm_px
pn2prm_px = deltaR*invrho2*prsqprm_px
ppprm_px = Qprm_px
sKerrmultfactprm_px = r*(-36*pn2prm_px + 3*ppprm_px)
sStarmultfactprm_px = r*(-30*pn2prm_px + 4*ppprm_px)
deltaSigmaStarUSCOREx1prm_px = etaover12r*(sKerrUSCOREx*sKerrmultfactprm_px + sStarUSCOREx*sStarmultfactprm_px)
deltaSigmaStarUSCOREy1prm_px = etaover12r*(sKerrUSCOREy*sKerrmultfactprm_px + sStarUSCOREy*sStarmultfactprm_px)
deltaSigmaStarUSCOREz1prm_px = etaover12r*(sKerrUSCOREz*sKerrmultfactprm_px + sStarUSCOREz*sStarmultfactprm_px)
pn2ppprm_px = pn2*ppprm_px + pn2prm_px*pp
pp2prm_px = 2*pp*ppprm_px
pn2u2prm_px = pn2prm_px*u2
ppu2prm_px = ppprm_px*u2
pn2ppu2prm_px = pn2ppprm_px*u2
sMultiplier1pt6prm_px = -720*pn2*pn2prm_px + 126*pn2ppprm_px + 3*pp2prm_px
sMultiplier1pt5prm_px = -96*pn2ppprm_px + 23*pp2prm_px
sMultiplier1pt4prm_px = 324*pn2prm_px - 120*ppprm_px + r*sMultiplier1pt6prm_px
sMultiplier1pt3prm_px = -282*pn2prm_px + 206*ppprm_px + r*sMultiplier1pt5prm_px
sMultiplier1pt2prm_px = r*sMultiplier1pt4prm_px
sMultiplier1pt1prm_px = eta*sMultiplier1pt2prm_px + r*sMultiplier1pt3prm_px
sMultiplier1prm_px = -eta*sMultiplier1pt1prm_px*u2/72
sMultiplier2pt6prm_px = 45*pn2*pn2u2prm_px/8 - 13*pn2ppu2prm_px/8 + 45*pn2prm_px*pn2u2/8
sMultiplier2pt5prm_px = pn2ppu2prm_px/4 - 5*pp2prm_px*u2/16
sMultiplier2pt4prm_px = -49*pn2u2prm_px/8 + 17*ppu2prm_px/12 + r*sMultiplier2pt6prm_px
sMultiplier2pt3prm_px = -2*pn2u2prm_px/3 - 109*ppu2prm_px/36 + r*sMultiplier2pt5prm_px
sMultiplier2pt2prm_px = r*sMultiplier2pt4prm_px
sMultiplier2pt1prm_px = eta*sMultiplier2pt2prm_px + r*sMultiplier2pt3prm_px
sMultiplier2prm_px = eta*sMultiplier2pt1prm_px
deltaSigmaStarUSCOREx2prm_px = deltaSigmaStarUSCOREx1prm_px + sMultiplier1prm_px*sigmaStar0 + sMultiplier2prm_px*sigmaKerr0
deltaSigmaStarUSCOREy2prm_px = deltaSigmaStarUSCOREy1prm_px + sMultiplier1prm_px*sigmaStar1 + sMultiplier2prm_px*sigmaKerr1
deltaSigmaStarUSCOREz2prm_px = deltaSigmaStarUSCOREz1prm_px + sMultiplier1prm_px*sigmaStar2 + sMultiplier2prm_px*sigmaKerr2
deltaSigmaStarUSCORExprm_px = deltaSigmaStarUSCOREx2prm_px
deltaSigmaStarUSCOREyprm_px = deltaSigmaStarUSCOREy2prm_px
deltaSigmaStarUSCOREzprm_px = deltaSigmaStarUSCOREz2prm_px
sxprm_px = deltaSigmaStarUSCORExprm_px
syprm_px = deltaSigmaStarUSCOREyprm_px
szprm_px = deltaSigmaStarUSCOREzprm_px
sxiprm_px = sxprm_px*xiUSCOREx + syprm_px*xiUSCOREy + szprm_px*xiUSCOREz
svprm_px = sxprm_px*vx + syprm_px*vy + szprm_px*vz
snprm_px = nx*sxprm_px + ny*syprm_px + nz*szprm_px
s3prm_px = e3USCOREx*sxprm_px + e3USCOREy*syprm_px + e3USCOREz*szprm_px
sqrtQprm_px = Qprm_px/(2*sp.sqrt(Q))
oneplus2sqrtQprm_px = 2*sqrtQprm_px
oneplus1sqrtQprm_px = oneplus2sqrtQprm_px - sqrtQprm_px
twoB1psqrtQsqrtQprm_px = 2*B*oneplus1sqrtQ*sqrtQprm_px + 2*B*oneplus1sqrtQprm_px*sqrtQ
invtwoB1psqrtQsqrtQprm_px = -twoB1psqrtQsqrtQprm_px/twoB1psqrtQsqrtQ**2
expMUsqsqrtQplusQprm_px = expMUsq*(Qprm_px + sqrtQprm_px)
Hwrpt4aprm_px = pxirsq*svprm_px + pxirsqprm_px*sv
Hwrpt4prm_px = Hwrpt4aprm_px*expMUsqexpnusq
Hwrpt3cprm_px = pxir*sxiprm_px + pxirprm_px*sxi
Hwrpt3bprm_px = Hwrpt3c*pvrprm_px + Hwrpt3cprm_px*pvr
Hwrpt3aprm_px = Hwrpt3bprm_px*expMUexpnu
Hwrpt3prm_px = B*Hwrpt3aprm_px
Hwrpt2gprm_px = deltaR*svprm_px
Hwrpt2fprm_px = snprm_px*sqrtdeltaR
Hwrpt2eprm_px = Hwrpt2f*pvrprm_px + Hwrpt2fprm_px*pvr
Hwrpt2dprm_px = Hwrpt2g*pnsqprm_px + Hwrpt2gprm_px*pnsq
Hwrpt2cprm_px = Hwrpt2e*pnprm_px + Hwrpt2eprm_px*pn
Hwrpt2bprm_px = expMUsqsqrtQplusQ*svprm_px + expMUsqsqrtQplusQprm_px*sv
Hwrpt2aprm_px = xi2*(Hwrpt2bprm_px + Hwrpt2cprm_px - Hwrpt2dprm_px)
Hwrpt2prm_px = Hwrpt2aprm_px*deltaT
Hwrpt1bprm_px = invtwoB1psqrtQsqrtQprm_px*invxi2
Hwrpt1aprm_px = Hwrpt1bprm_px*sqrtdeltaR
Hwrpt1prm_px = Hwrpt1aprm_px*invexpMUcubinvexpnu
Hwrprm_px = Hwrpt1*(Hwrpt2prm_px - Hwrpt3prm_px + Hwrpt4prm_px) + Hwrpt1prm_px*(Hwrpt2 - Hwrpt3 + Hwrpt4)
Hwcospt9prm_px = pxir*sxiprm_px + pxirprm_px*sxi
Hwcospt8prm_px = pvr*svprm_px + pvrprm_px*sv
Hwcospt7prm_px = B*Hwcospt8prm_px - Hwcospt9prm_px*expMUexpnu
Hwcospt6prm_px = Hwcospt7prm_px*sqrtdeltaR
Hwcospt5prm_px = -expMUsqsqrtQplusQprm_px*xi2 + pvrsqprm_px
Hwcospt4prm_px = Hwcospt6*pnprm_px + Hwcospt6prm_px*pn
Hwcospt3prm_px = Hwcospt5prm_px*deltaT - expMUsqexpnusq*pxirsqprm_px
Hwcospt2prm_px = -B*Hwcospt4prm_px + Hwcospt3*snprm_px + Hwcospt3prm_px*sn
Hwcospt1prm_px = Hwcospt2prm_px*invexpMUcubinvexpnu
Hwcosprm_px = Hwcospt1*invtwoB1psqrtQsqrtQprm_px + Hwcospt1prm_px*invtwoB1psqrtQsqrtQ
deltaTsqrtQprm_px = deltaT*sqrtQprm_px
invdeltatTsqrtQprm_px = -deltaTsqrtQprm_px/deltaTsqrtQ**2
HSOLpt5prm_px = pxirprm_px*(-B + expMUexpnu)
HSOLpt4prm_px = HSOLpt5prm_px*invexpMU
HSOLpt3prm_px = HSOLpt4prm_px*expnusq
HSOLpt2prm_px = HSOLpt3*s3prm_px + HSOLpt3prm_px*s3
HSOLpt1prm_px = HSOLpt2prm_px*invxi2
HSOLprm_px = HSOLpt1*invdeltatTsqrtQprm_px + HSOLpt1prm_px*invdeltatTsqrtQ
deltaTsqrtQplusQprm_px = deltaT*(Qprm_px + sqrtQprm_px)
invdeltaTsqrtQplusQprm_px = -deltaTsqrtQplusQprm_px/deltaTsqrtQplusQ**2
HSONLmult2prm_px = invdeltaTsqrtQplusQprm_px*invxi2
HSONLmultprm_px = HSONLmult2prm_px*expnuinvexpMU2
HSONLpt1bprm_px = pnprm_px*xi2
HSONLpt1aprm_px = HSONLpt1bprm_px*(-mucos + nucos) + mur*pvrprm_px - nur*pvrprm_px
HSONLpt1prm_px = HSONLpt1a*sqrtQprm_px + HSONLpt1aprm_px*sqrtQ - HSONLpt1bprm_px*mucos + mur*pvrprm_px
HSONLpt2dprm_px = nur*pxirprm_px
HSONLpt2cprm_px = HSONLpt2d*oneplus2sqrtQprm_px + HSONLpt2dprm_px*oneplus2sqrtQ
HSONLpt2bprm_px = B*sxiprm_px
HSONLpt2aprm_px = HSONLpt2cprm_px*expMUexpnu
HSONLpt2prm_px = HSONLpt1*HSONLpt2bprm_px + HSONLpt1prm_px*HSONLpt2b + HSONLpt2a*svprm_px + HSONLpt2aprm_px*sv
HSONLpt3cprm_px = pxir*svprm_px + pxirprm_px*sv
HSONLpt3bprm_px = HSONLpt3c*oneplus1sqrtQprm_px + HSONLpt3cprm_px*oneplus1sqrtQ
HSONLpt3aprm_px = HSONLpt3bprm_px*expMUexpnu
HSONLpt3prm_px = B*HSONLpt2prm_px - BR*HSONLpt3aprm_px
HSONLpt4eprm_px = snprm_px*xi2
HSONLpt4dprm_px = HSONLpt4e*oneplus2sqrtQprm_px + HSONLpt4eprm_px*oneplus2sqrtQ
HSONLpt4cprm_px = HSONLpt4d*pxirprm_px + HSONLpt4dprm_px*pxir
HSONLpt4bprm_px = HSONLpt4cprm_px*nucos
HSONLpt4aprm_px = HSONLpt4bprm_px*expMUexpnu
HSONLpt4prm_px = -B*HSONLpt4aprm_px + HSONLpt3prm_px*sqrtdeltaR
HSONLprm_px = HSONLmult*HSONLpt4prm_px + HSONLmultprm_px*HSONLpt4
Hsprm_px = HSOLprm_px + HSONLprm_px + Hwcosprm_px*wcos + Hwrprm_px*wr + s3prm_px*w
Hsspt1prm_px = 3*sn*snprm_px - sx*sxprm_px - sy*syprm_px - sz*szprm_px
Hssprm_px = Hsspt1prm_px*u3
Hprm_px = Hnsprm_px + Hsprm_px + Hssprm_px
Hrealprm_px = Hprm_px*eta*sp.sign(H)/sp.sqrt(2*eta*(sp.Abs(H) - 1) + 1)
prTprm_py = csi2*ny
prTtimesoneminuscsi1invprm_py = prTprm_py*(1 - 1/csi1)
tmppxprm_py = -nx*prTtimesoneminuscsi1invprm_py
tmppyprm_py = -ny*prTtimesoneminuscsi1invprm_py + 1
tmppzprm_py = -nz*prTtimesoneminuscsi1invprm_py
pxirprm_py = r*(tmppxprm_py*xiUSCOREx + tmppyprm_py*xiUSCOREy + tmppzprm_py*xiUSCOREz)
pvrprm_py = r*(tmppxprm_py*vx + tmppyprm_py*vy + tmppzprm_py*vz)
pvrsqprm_py = 2*pvr*pvrprm_py
pnprm_py = nx*tmppxprm_py + ny*tmppyprm_py + nz*tmppzprm_py
pnsqprm_py = 2*pn*pnprm_py
prprm_py = pnprm_py
prsqprm_py = 2*pr*prprm_py
pfprm_py = pxirprm_py
pxirsqprm_py = 2*pxir*pxirprm_py
ptheta2prm_py = invxi2*pvrsqprm_py
prT4prm_py = 4*prT**3*prTprm_py
Hnspt4prm_py = Hnspt5*prT4prm_py + 2*Hnspt6*pf*pfprm_py + Hnspt7*prsqprm_py + invrho2*ptheta2prm_py
Hnspt3prm_py = Hnspt4prm_py*deltaT
Hnspt2prm_py = Hnspt3prm_py*rho2
Hnspt1prm_py = pfprm_py*ww
Hnsprm_py = Hnspt1prm_py*invLamb + Hnspt2prm_py*sp.sqrt(Hnspt2*invLamb)/(2*Hnspt2)
Qprm_py = Qpt1*pvrsqprm_py + Qpt2*pxirsqprm_py + Qpt3*pnsqprm_py
pn2prm_py = deltaR*invrho2*prsqprm_py
ppprm_py = Qprm_py
sKerrmultfactprm_py = r*(-36*pn2prm_py + 3*ppprm_py)
sStarmultfactprm_py = r*(-30*pn2prm_py + 4*ppprm_py)
deltaSigmaStarUSCOREx1prm_py = etaover12r*(sKerrUSCOREx*sKerrmultfactprm_py + sStarUSCOREx*sStarmultfactprm_py)
deltaSigmaStarUSCOREy1prm_py = etaover12r*(sKerrUSCOREy*sKerrmultfactprm_py + sStarUSCOREy*sStarmultfactprm_py)
deltaSigmaStarUSCOREz1prm_py = etaover12r*(sKerrUSCOREz*sKerrmultfactprm_py + sStarUSCOREz*sStarmultfactprm_py)
pn2ppprm_py = pn2*ppprm_py + pn2prm_py*pp
pp2prm_py = 2*pp*ppprm_py
pn2u2prm_py = pn2prm_py*u2
ppu2prm_py = ppprm_py*u2
pn2ppu2prm_py = pn2ppprm_py*u2
sMultiplier1pt6prm_py = -720*pn2*pn2prm_py + 126*pn2ppprm_py + 3*pp2prm_py
sMultiplier1pt5prm_py = -96*pn2ppprm_py + 23*pp2prm_py
sMultiplier1pt4prm_py = 324*pn2prm_py - 120*ppprm_py + r*sMultiplier1pt6prm_py
sMultiplier1pt3prm_py = -282*pn2prm_py + 206*ppprm_py + r*sMultiplier1pt5prm_py
sMultiplier1pt2prm_py = r*sMultiplier1pt4prm_py
sMultiplier1pt1prm_py = eta*sMultiplier1pt2prm_py + r*sMultiplier1pt3prm_py
sMultiplier1prm_py = -eta*sMultiplier1pt1prm_py*u2/72
sMultiplier2pt6prm_py = 45*pn2*pn2u2prm_py/8 - 13*pn2ppu2prm_py/8 + 45*pn2prm_py*pn2u2/8
sMultiplier2pt5prm_py = pn2ppu2prm_py/4 - 5*pp2prm_py*u2/16
sMultiplier2pt4prm_py = -49*pn2u2prm_py/8 + 17*ppu2prm_py/12 + r*sMultiplier2pt6prm_py
sMultiplier2pt3prm_py = -2*pn2u2prm_py/3 - 109*ppu2prm_py/36 + r*sMultiplier2pt5prm_py
sMultiplier2pt2prm_py = r*sMultiplier2pt4prm_py
sMultiplier2pt1prm_py = eta*sMultiplier2pt2prm_py + r*sMultiplier2pt3prm_py
sMultiplier2prm_py = eta*sMultiplier2pt1prm_py
deltaSigmaStarUSCOREx2prm_py = deltaSigmaStarUSCOREx1prm_py + sMultiplier1prm_py*sigmaStar0 + sMultiplier2prm_py*sigmaKerr0
deltaSigmaStarUSCOREy2prm_py = deltaSigmaStarUSCOREy1prm_py + sMultiplier1prm_py*sigmaStar1 + sMultiplier2prm_py*sigmaKerr1
deltaSigmaStarUSCOREz2prm_py = deltaSigmaStarUSCOREz1prm_py + sMultiplier1prm_py*sigmaStar2 + sMultiplier2prm_py*sigmaKerr2
deltaSigmaStarUSCORExprm_py = deltaSigmaStarUSCOREx2prm_py
deltaSigmaStarUSCOREyprm_py = deltaSigmaStarUSCOREy2prm_py
deltaSigmaStarUSCOREzprm_py = deltaSigmaStarUSCOREz2prm_py
sxprm_py = deltaSigmaStarUSCORExprm_py
syprm_py = deltaSigmaStarUSCOREyprm_py
szprm_py = deltaSigmaStarUSCOREzprm_py
sxiprm_py = sxprm_py*xiUSCOREx + syprm_py*xiUSCOREy + szprm_py*xiUSCOREz
svprm_py = sxprm_py*vx + syprm_py*vy + szprm_py*vz
snprm_py = nx*sxprm_py + ny*syprm_py + nz*szprm_py
s3prm_py = e3USCOREx*sxprm_py + e3USCOREy*syprm_py + e3USCOREz*szprm_py
sqrtQprm_py = Qprm_py/(2*sp.sqrt(Q))
oneplus2sqrtQprm_py = 2*sqrtQprm_py
oneplus1sqrtQprm_py = oneplus2sqrtQprm_py - sqrtQprm_py
twoB1psqrtQsqrtQprm_py = 2*B*oneplus1sqrtQ*sqrtQprm_py + 2*B*oneplus1sqrtQprm_py*sqrtQ
invtwoB1psqrtQsqrtQprm_py = -twoB1psqrtQsqrtQprm_py/twoB1psqrtQsqrtQ**2
expMUsqsqrtQplusQprm_py = expMUsq*(Qprm_py + sqrtQprm_py)
Hwrpt4aprm_py = pxirsq*svprm_py + pxirsqprm_py*sv
Hwrpt4prm_py = Hwrpt4aprm_py*expMUsqexpnusq
Hwrpt3cprm_py = pxir*sxiprm_py + pxirprm_py*sxi
Hwrpt3bprm_py = Hwrpt3c*pvrprm_py + Hwrpt3cprm_py*pvr
Hwrpt3aprm_py = Hwrpt3bprm_py*expMUexpnu
Hwrpt3prm_py = B*Hwrpt3aprm_py
Hwrpt2gprm_py = deltaR*svprm_py
Hwrpt2fprm_py = snprm_py*sqrtdeltaR
Hwrpt2eprm_py = Hwrpt2f*pvrprm_py + Hwrpt2fprm_py*pvr
Hwrpt2dprm_py = Hwrpt2g*pnsqprm_py + Hwrpt2gprm_py*pnsq
Hwrpt2cprm_py = Hwrpt2e*pnprm_py + Hwrpt2eprm_py*pn
Hwrpt2bprm_py = expMUsqsqrtQplusQ*svprm_py + expMUsqsqrtQplusQprm_py*sv
Hwrpt2aprm_py = xi2*(Hwrpt2bprm_py + Hwrpt2cprm_py - Hwrpt2dprm_py)
Hwrpt2prm_py = Hwrpt2aprm_py*deltaT
Hwrpt1bprm_py = invtwoB1psqrtQsqrtQprm_py*invxi2
Hwrpt1aprm_py = Hwrpt1bprm_py*sqrtdeltaR
Hwrpt1prm_py = Hwrpt1aprm_py*invexpMUcubinvexpnu
Hwrprm_py = Hwrpt1*(Hwrpt2prm_py - Hwrpt3prm_py + Hwrpt4prm_py) + Hwrpt1prm_py*(Hwrpt2 - Hwrpt3 + Hwrpt4)
Hwcospt9prm_py = pxir*sxiprm_py + pxirprm_py*sxi
Hwcospt8prm_py = pvr*svprm_py + pvrprm_py*sv
Hwcospt7prm_py = B*Hwcospt8prm_py - Hwcospt9prm_py*expMUexpnu
Hwcospt6prm_py = Hwcospt7prm_py*sqrtdeltaR
Hwcospt5prm_py = -expMUsqsqrtQplusQprm_py*xi2 + pvrsqprm_py
Hwcospt4prm_py = Hwcospt6*pnprm_py + Hwcospt6prm_py*pn
Hwcospt3prm_py = Hwcospt5prm_py*deltaT - expMUsqexpnusq*pxirsqprm_py
Hwcospt2prm_py = -B*Hwcospt4prm_py + Hwcospt3*snprm_py + Hwcospt3prm_py*sn
Hwcospt1prm_py = Hwcospt2prm_py*invexpMUcubinvexpnu
Hwcosprm_py = Hwcospt1*invtwoB1psqrtQsqrtQprm_py + Hwcospt1prm_py*invtwoB1psqrtQsqrtQ
deltaTsqrtQprm_py = deltaT*sqrtQprm_py
invdeltatTsqrtQprm_py = -deltaTsqrtQprm_py/deltaTsqrtQ**2
HSOLpt5prm_py = pxirprm_py*(-B + expMUexpnu)
HSOLpt4prm_py = HSOLpt5prm_py*invexpMU
HSOLpt3prm_py = HSOLpt4prm_py*expnusq
HSOLpt2prm_py = HSOLpt3*s3prm_py + HSOLpt3prm_py*s3
HSOLpt1prm_py = HSOLpt2prm_py*invxi2
HSOLprm_py = HSOLpt1*invdeltatTsqrtQprm_py + HSOLpt1prm_py*invdeltatTsqrtQ
deltaTsqrtQplusQprm_py = deltaT*(Qprm_py + sqrtQprm_py)
invdeltaTsqrtQplusQprm_py = -deltaTsqrtQplusQprm_py/deltaTsqrtQplusQ**2
HSONLmult2prm_py = invdeltaTsqrtQplusQprm_py*invxi2
HSONLmultprm_py = HSONLmult2prm_py*expnuinvexpMU2
HSONLpt1bprm_py = pnprm_py*xi2
HSONLpt1aprm_py = HSONLpt1bprm_py*(-mucos + nucos) + mur*pvrprm_py - nur*pvrprm_py
HSONLpt1prm_py = HSONLpt1a*sqrtQprm_py + HSONLpt1aprm_py*sqrtQ - HSONLpt1bprm_py*mucos + mur*pvrprm_py
HSONLpt2dprm_py = nur*pxirprm_py
HSONLpt2cprm_py = HSONLpt2d*oneplus2sqrtQprm_py + HSONLpt2dprm_py*oneplus2sqrtQ
HSONLpt2bprm_py = B*sxiprm_py
HSONLpt2aprm_py = HSONLpt2cprm_py*expMUexpnu
HSONLpt2prm_py = HSONLpt1*HSONLpt2bprm_py + HSONLpt1prm_py*HSONLpt2b + HSONLpt2a*svprm_py + HSONLpt2aprm_py*sv
HSONLpt3cprm_py = pxir*svprm_py + pxirprm_py*sv
HSONLpt3bprm_py = HSONLpt3c*oneplus1sqrtQprm_py + HSONLpt3cprm_py*oneplus1sqrtQ
HSONLpt3aprm_py = HSONLpt3bprm_py*expMUexpnu
HSONLpt3prm_py = B*HSONLpt2prm_py - BR*HSONLpt3aprm_py
HSONLpt4eprm_py = snprm_py*xi2
HSONLpt4dprm_py = HSONLpt4e*oneplus2sqrtQprm_py + HSONLpt4eprm_py*oneplus2sqrtQ
HSONLpt4cprm_py = HSONLpt4d*pxirprm_py + HSONLpt4dprm_py*pxir
HSONLpt4bprm_py = HSONLpt4cprm_py*nucos
HSONLpt4aprm_py = HSONLpt4bprm_py*expMUexpnu
HSONLpt4prm_py = -B*HSONLpt4aprm_py + HSONLpt3prm_py*sqrtdeltaR
HSONLprm_py = HSONLmult*HSONLpt4prm_py + HSONLmultprm_py*HSONLpt4
Hsprm_py = HSOLprm_py + HSONLprm_py + Hwcosprm_py*wcos + Hwrprm_py*wr + s3prm_py*w
Hsspt1prm_py = 3*sn*snprm_py - sx*sxprm_py - sy*syprm_py - sz*szprm_py
Hssprm_py = Hsspt1prm_py*u3
Hprm_py = Hnsprm_py + Hsprm_py + Hssprm_py
Hrealprm_py = Hprm_py*eta*sp.sign(H)/sp.sqrt(2*eta*(sp.Abs(H) - 1) + 1)
prTprm_pz = csi2*nz
prTtimesoneminuscsi1invprm_pz = prTprm_pz*(1 - 1/csi1)
tmppxprm_pz = -nx*prTtimesoneminuscsi1invprm_pz
tmppyprm_pz = -ny*prTtimesoneminuscsi1invprm_pz
tmppzprm_pz = -nz*prTtimesoneminuscsi1invprm_pz + 1
pxirprm_pz = r*(tmppxprm_pz*xiUSCOREx + tmppyprm_pz*xiUSCOREy + tmppzprm_pz*xiUSCOREz)
pvrprm_pz = r*(tmppxprm_pz*vx + tmppyprm_pz*vy + tmppzprm_pz*vz)
pvrsqprm_pz = 2*pvr*pvrprm_pz
pnprm_pz = nx*tmppxprm_pz + ny*tmppyprm_pz + nz*tmppzprm_pz
pnsqprm_pz = 2*pn*pnprm_pz
prprm_pz = pnprm_pz
prsqprm_pz = 2*pr*prprm_pz
pfprm_pz = pxirprm_pz
pxirsqprm_pz = 2*pxir*pxirprm_pz
ptheta2prm_pz = invxi2*pvrsqprm_pz
prT4prm_pz = 4*prT**3*prTprm_pz
Hnspt4prm_pz = Hnspt5*prT4prm_pz + 2*Hnspt6*pf*pfprm_pz + Hnspt7*prsqprm_pz + invrho2*ptheta2prm_pz
Hnspt3prm_pz = Hnspt4prm_pz*deltaT
Hnspt2prm_pz = Hnspt3prm_pz*rho2
Hnspt1prm_pz = pfprm_pz*ww
Hnsprm_pz = Hnspt1prm_pz*invLamb + Hnspt2prm_pz*sp.sqrt(Hnspt2*invLamb)/(2*Hnspt2)
Qprm_pz = Qpt1*pvrsqprm_pz + Qpt2*pxirsqprm_pz + Qpt3*pnsqprm_pz
pn2prm_pz = deltaR*invrho2*prsqprm_pz
ppprm_pz = Qprm_pz
sKerrmultfactprm_pz = r*(-36*pn2prm_pz + 3*ppprm_pz)
sStarmultfactprm_pz = r*(-30*pn2prm_pz + 4*ppprm_pz)
deltaSigmaStarUSCOREx1prm_pz = etaover12r*(sKerrUSCOREx*sKerrmultfactprm_pz + sStarUSCOREx*sStarmultfactprm_pz)
deltaSigmaStarUSCOREy1prm_pz = etaover12r*(sKerrUSCOREy*sKerrmultfactprm_pz + sStarUSCOREy*sStarmultfactprm_pz)
deltaSigmaStarUSCOREz1prm_pz = etaover12r*(sKerrUSCOREz*sKerrmultfactprm_pz + sStarUSCOREz*sStarmultfactprm_pz)
pn2ppprm_pz = pn2*ppprm_pz + pn2prm_pz*pp
pp2prm_pz = 2*pp*ppprm_pz
pn2u2prm_pz = pn2prm_pz*u2
ppu2prm_pz = ppprm_pz*u2
pn2ppu2prm_pz = pn2ppprm_pz*u2
sMultiplier1pt6prm_pz = -720*pn2*pn2prm_pz + 126*pn2ppprm_pz + 3*pp2prm_pz
sMultiplier1pt5prm_pz = -96*pn2ppprm_pz + 23*pp2prm_pz
sMultiplier1pt4prm_pz = 324*pn2prm_pz - 120*ppprm_pz + r*sMultiplier1pt6prm_pz
sMultiplier1pt3prm_pz = -282*pn2prm_pz + 206*ppprm_pz + r*sMultiplier1pt5prm_pz
sMultiplier1pt2prm_pz = r*sMultiplier1pt4prm_pz
sMultiplier1pt1prm_pz = eta*sMultiplier1pt2prm_pz + r*sMultiplier1pt3prm_pz
sMultiplier1prm_pz = -eta*sMultiplier1pt1prm_pz*u2/72
sMultiplier2pt6prm_pz = 45*pn2*pn2u2prm_pz/8 - 13*pn2ppu2prm_pz/8 + 45*pn2prm_pz*pn2u2/8
sMultiplier2pt5prm_pz = pn2ppu2prm_pz/4 - 5*pp2prm_pz*u2/16
sMultiplier2pt4prm_pz = -49*pn2u2prm_pz/8 + 17*ppu2prm_pz/12 + r*sMultiplier2pt6prm_pz
sMultiplier2pt3prm_pz = -2*pn2u2prm_pz/3 - 109*ppu2prm_pz/36 + r*sMultiplier2pt5prm_pz
sMultiplier2pt2prm_pz = r*sMultiplier2pt4prm_pz
sMultiplier2pt1prm_pz = eta*sMultiplier2pt2prm_pz + r*sMultiplier2pt3prm_pz
sMultiplier2prm_pz = eta*sMultiplier2pt1prm_pz
deltaSigmaStarUSCOREx2prm_pz = deltaSigmaStarUSCOREx1prm_pz + sMultiplier1prm_pz*sigmaStar0 + sMultiplier2prm_pz*sigmaKerr0
deltaSigmaStarUSCOREy2prm_pz = deltaSigmaStarUSCOREy1prm_pz + sMultiplier1prm_pz*sigmaStar1 + sMultiplier2prm_pz*sigmaKerr1
deltaSigmaStarUSCOREz2prm_pz = deltaSigmaStarUSCOREz1prm_pz + sMultiplier1prm_pz*sigmaStar2 + sMultiplier2prm_pz*sigmaKerr2
deltaSigmaStarUSCORExprm_pz = deltaSigmaStarUSCOREx2prm_pz
deltaSigmaStarUSCOREyprm_pz = deltaSigmaStarUSCOREy2prm_pz
deltaSigmaStarUSCOREzprm_pz = deltaSigmaStarUSCOREz2prm_pz
sxprm_pz = deltaSigmaStarUSCORExprm_pz
syprm_pz = deltaSigmaStarUSCOREyprm_pz
szprm_pz = deltaSigmaStarUSCOREzprm_pz
sxiprm_pz = sxprm_pz*xiUSCOREx + syprm_pz*xiUSCOREy + szprm_pz*xiUSCOREz
svprm_pz = sxprm_pz*vx + syprm_pz*vy + szprm_pz*vz
snprm_pz = nx*sxprm_pz + ny*syprm_pz + nz*szprm_pz
s3prm_pz = e3USCOREx*sxprm_pz + e3USCOREy*syprm_pz + e3USCOREz*szprm_pz
sqrtQprm_pz = Qprm_pz/(2*sp.sqrt(Q))
oneplus2sqrtQprm_pz = 2*sqrtQprm_pz
oneplus1sqrtQprm_pz = oneplus2sqrtQprm_pz - sqrtQprm_pz
twoB1psqrtQsqrtQprm_pz = 2*B*oneplus1sqrtQ*sqrtQprm_pz + 2*B*oneplus1sqrtQprm_pz*sqrtQ
invtwoB1psqrtQsqrtQprm_pz = -twoB1psqrtQsqrtQprm_pz/twoB1psqrtQsqrtQ**2
expMUsqsqrtQplusQprm_pz = expMUsq*(Qprm_pz + sqrtQprm_pz)
Hwrpt4aprm_pz = pxirsq*svprm_pz + pxirsqprm_pz*sv
Hwrpt4prm_pz = Hwrpt4aprm_pz*expMUsqexpnusq
Hwrpt3cprm_pz = pxir*sxiprm_pz + pxirprm_pz*sxi
Hwrpt3bprm_pz = Hwrpt3c*pvrprm_pz + Hwrpt3cprm_pz*pvr
Hwrpt3aprm_pz = Hwrpt3bprm_pz*expMUexpnu
Hwrpt3prm_pz = B*Hwrpt3aprm_pz
Hwrpt2gprm_pz = deltaR*svprm_pz
Hwrpt2fprm_pz = snprm_pz*sqrtdeltaR
Hwrpt2eprm_pz = Hwrpt2f*pvrprm_pz + Hwrpt2fprm_pz*pvr
Hwrpt2dprm_pz = Hwrpt2g*pnsqprm_pz + Hwrpt2gprm_pz*pnsq
Hwrpt2cprm_pz = Hwrpt2e*pnprm_pz + Hwrpt2eprm_pz*pn
Hwrpt2bprm_pz = expMUsqsqrtQplusQ*svprm_pz + expMUsqsqrtQplusQprm_pz*sv
Hwrpt2aprm_pz = xi2*(Hwrpt2bprm_pz + Hwrpt2cprm_pz - Hwrpt2dprm_pz)
Hwrpt2prm_pz = Hwrpt2aprm_pz*deltaT
Hwrpt1bprm_pz = invtwoB1psqrtQsqrtQprm_pz*invxi2
Hwrpt1aprm_pz = Hwrpt1bprm_pz*sqrtdeltaR
Hwrpt1prm_pz = Hwrpt1aprm_pz*invexpMUcubinvexpnu
Hwrprm_pz = Hwrpt1*(Hwrpt2prm_pz - Hwrpt3prm_pz + Hwrpt4prm_pz) + Hwrpt1prm_pz*(Hwrpt2 - Hwrpt3 + Hwrpt4)
Hwcospt9prm_pz = pxir*sxiprm_pz + pxirprm_pz*sxi
Hwcospt8prm_pz = pvr*svprm_pz + pvrprm_pz*sv
Hwcospt7prm_pz = B*Hwcospt8prm_pz - Hwcospt9prm_pz*expMUexpnu
Hwcospt6prm_pz = Hwcospt7prm_pz*sqrtdeltaR
Hwcospt5prm_pz = -expMUsqsqrtQplusQprm_pz*xi2 + pvrsqprm_pz
Hwcospt4prm_pz = Hwcospt6*pnprm_pz + Hwcospt6prm_pz*pn
Hwcospt3prm_pz = Hwcospt5prm_pz*deltaT - expMUsqexpnusq*pxirsqprm_pz
Hwcospt2prm_pz = -B*Hwcospt4prm_pz + Hwcospt3*snprm_pz + Hwcospt3prm_pz*sn
Hwcospt1prm_pz = Hwcospt2prm_pz*invexpMUcubinvexpnu
Hwcosprm_pz = Hwcospt1*invtwoB1psqrtQsqrtQprm_pz + Hwcospt1prm_pz*invtwoB1psqrtQsqrtQ
deltaTsqrtQprm_pz = deltaT*sqrtQprm_pz
invdeltatTsqrtQprm_pz = -deltaTsqrtQprm_pz/deltaTsqrtQ**2
HSOLpt5prm_pz = pxirprm_pz*(-B + expMUexpnu)
HSOLpt4prm_pz = HSOLpt5prm_pz*invexpMU
HSOLpt3prm_pz = HSOLpt4prm_pz*expnusq
HSOLpt2prm_pz = HSOLpt3*s3prm_pz + HSOLpt3prm_pz*s3
HSOLpt1prm_pz = HSOLpt2prm_pz*invxi2
HSOLprm_pz = HSOLpt1*invdeltatTsqrtQprm_pz + HSOLpt1prm_pz*invdeltatTsqrtQ
deltaTsqrtQplusQprm_pz = deltaT*(Qprm_pz + sqrtQprm_pz)
invdeltaTsqrtQplusQprm_pz = -deltaTsqrtQplusQprm_pz/deltaTsqrtQplusQ**2
HSONLmult2prm_pz = invdeltaTsqrtQplusQprm_pz*invxi2
HSONLmultprm_pz = HSONLmult2prm_pz*expnuinvexpMU2
HSONLpt1bprm_pz = pnprm_pz*xi2
HSONLpt1aprm_pz = HSONLpt1bprm_pz*(-mucos + nucos) + mur*pvrprm_pz - nur*pvrprm_pz
HSONLpt1prm_pz = HSONLpt1a*sqrtQprm_pz + HSONLpt1aprm_pz*sqrtQ - HSONLpt1bprm_pz*mucos + mur*pvrprm_pz
HSONLpt2dprm_pz = nur*pxirprm_pz
HSONLpt2cprm_pz = HSONLpt2d*oneplus2sqrtQprm_pz + HSONLpt2dprm_pz*oneplus2sqrtQ
HSONLpt2bprm_pz = B*sxiprm_pz
HSONLpt2aprm_pz = HSONLpt2cprm_pz*expMUexpnu
HSONLpt2prm_pz = HSONLpt1*HSONLpt2bprm_pz + HSONLpt1prm_pz*HSONLpt2b + HSONLpt2a*svprm_pz + HSONLpt2aprm_pz*sv
HSONLpt3cprm_pz = pxir*svprm_pz + pxirprm_pz*sv
HSONLpt3bprm_pz = HSONLpt3c*oneplus1sqrtQprm_pz + HSONLpt3cprm_pz*oneplus1sqrtQ
HSONLpt3aprm_pz = HSONLpt3bprm_pz*expMUexpnu
HSONLpt3prm_pz = B*HSONLpt2prm_pz - BR*HSONLpt3aprm_pz
HSONLpt4eprm_pz = snprm_pz*xi2
HSONLpt4dprm_pz = HSONLpt4e*oneplus2sqrtQprm_pz + HSONLpt4eprm_pz*oneplus2sqrtQ
HSONLpt4cprm_pz = HSONLpt4d*pxirprm_pz + HSONLpt4dprm_pz*pxir
HSONLpt4bprm_pz = HSONLpt4cprm_pz*nucos
HSONLpt4aprm_pz = HSONLpt4bprm_pz*expMUexpnu
HSONLpt4prm_pz = -B*HSONLpt4aprm_pz + HSONLpt3prm_pz*sqrtdeltaR
HSONLprm_pz = HSONLmult*HSONLpt4prm_pz + HSONLmultprm_pz*HSONLpt4
Hsprm_pz = HSOLprm_pz + HSONLprm_pz + Hwcosprm_pz*wcos + Hwrprm_pz*wr + s3prm_pz*w
Hsspt1prm_pz = 3*sn*snprm_pz - sx*sxprm_pz - sy*syprm_pz - sz*szprm_pz
Hssprm_pz = Hsspt1prm_pz*u3
Hprm_pz = Hnsprm_pz + Hsprm_pz + Hssprm_pz
Hrealprm_pz = Hprm_pz*eta*sp.sign(H)/sp.sqrt(2*eta*(sp.Abs(H) - 1) + 1)
sigmaKerr0prm_s1x = 1
sigmaStar0prm_s1x = m2overm1
s1dots1prm_s1x = 2*s1x
sKerrUSCORExprm_s1x = sigmaKerr0prm_s1x
sStarUSCORExprm_s1x = sigmaStar0prm_s1x
a2prm_s1x = 2*sKerrUSCOREx*sKerrUSCORExprm_s1x
a4prm_s1x = 2*a2*a2prm_s1x
aprm_s1x = a2prm_s1x/(2*sp.sqrt(a2))
invaprm_s1x = -aprm_s1x/a**2
k2prm_s1x = -a2prm_s1x*k0*m1PlusetaKKsq
k2sqprm_s1x = 2*k2*k2prm_s1x
k3prm_s1x = -a2prm_s1x*k1*m1PlusetaKKsq + k1*k2prm_s1x - 2.0*k2prm_s1x*m1PlusetaKK
k4prm_s1x = -1.0*a2*k2prm_s1x*m1PlusetaKKsq + a2prm_s1x*m1PlusetaKKsq*(0.5*k1sq - 1.0*k2) + 0.0833333333333333*k1*(24*k2prm_s1x*m1PlusetaKK + 12*k3prm_s1x) - 1.0*k1sq*k2prm_s1x + 1.0*k2*k2prm_s1x - 2.0*k3prm_s1x*m1PlusetaKK
k5prm_s1x = m1PlusetaKKsq*(a2*(1.0*k1*k2prm_s1x - 1.0*k3prm_s1x) + a2prm_s1x*(1.0*k1*k2 - 0.333333333333333*k1cu - 1.0*k3) - (1.0*k1*k2sqprm_s1x - 1.0*k1*k4prm_s1x - 1.0*k1cu*k2prm_s1x + 1.0*k1sq*k3prm_s1x - 1.0*k2*k3prm_s1x - 1.0*k2prm_s1x*k3)/m1PlusetaKKsq + (4.0*k1*k3prm_s1x - 4.0*k1sq*k2prm_s1x + 2.0*k2sqprm_s1x - 4.0*k4prm_s1x)/(2*m1PlusetaKK))
e3USCORExprm_s1x = inva*sKerrUSCORExprm_s1x + invaprm_s1x*sKerrUSCOREx
e3USCOREyprm_s1x = invaprm_s1x*sKerrUSCOREy
e3USCOREzprm_s1x = invaprm_s1x*sKerrUSCOREz
costhetaprm_s1x = e3USCORExprm_s1x*nx + e3USCOREyprm_s1x*ny + e3USCOREzprm_s1x*nz
xi2prm_s1x = -2*costheta*costhetaprm_s1x
xiUSCORExprm_s1x = e3USCOREyprm_s1x*nz - e3USCOREzprm_s1x*ny
xiUSCOREyprm_s1x = -e3USCORExprm_s1x*nz + e3USCOREzprm_s1x*nx
xiUSCOREzprm_s1x = e3USCORExprm_s1x*ny - e3USCOREyprm_s1x*nx
vxprm_s1x = ny*xiUSCOREzprm_s1x - nz*xiUSCOREyprm_s1x
vyprm_s1x = -nx*xiUSCOREzprm_s1x + nz*xiUSCORExprm_s1x
vzprm_s1x = nx*xiUSCOREyprm_s1x - ny*xiUSCORExprm_s1x
w2prm_s1x = a2prm_s1x
rho2prm_s1x = 2*a2*costheta*costhetaprm_s1x + a2prm_s1x*costheta**2
bulkprm_s1x = a2prm_s1x*u2
logargprm_s1x = k2prm_s1x*u2 + k3prm_s1x*u3 + k4prm_s1x*u4 + k5prm_s1x*u5
onepluslogargprm_s1x = logargprm_s1x
invonepluslogargprm_s1x = -onepluslogargprm_s1x/onepluslogarg**2
logTermsprm_s1x = eta*onepluslogargprm_s1x*sp.sign(onepluslogarg)/sp.Abs(onepluslogarg)
deltaUprm_s1x = (bulk*logTermsprm_s1x + bulkprm_s1x*logTerms)*sp.sign(bulk*logTerms)
deltaTprm_s1x = deltaUprm_s1x*r2
deltaUUSCOREupt7prm_s1x = k5prm_s1x
deltaUUSCOREupt6prm_s1x = 5*deltaUUSCOREupt7prm_s1x*u + 4*k4prm_s1x
deltaUUSCOREupt5prm_s1x = deltaUUSCOREupt6prm_s1x*u + 3*k3prm_s1x
deltaUUSCOREupt4prm_s1x = deltaUUSCOREupt5prm_s1x*u + 2*k2prm_s1x
deltaUUSCOREupt3prm_s1x = deltaUUSCOREupt4prm_s1x*u
deltaUUSCOREupt2prm_s1x = a2prm_s1x*u
deltaUUSCOREupt1prm_s1x = bulk*deltaUUSCOREupt3prm_s1x*eta + bulkprm_s1x*deltaUUSCOREupt3*eta
deltaUUSCOREuprm_s1x = deltaUUSCOREupt1*invonepluslogargprm_s1x + deltaUUSCOREupt1prm_s1x*invonepluslogarg + 2*deltaUUSCOREupt2*logTermsprm_s1x + 2*deltaUUSCOREupt2prm_s1x*logTerms
deltaTUSCORErprm_s1x = -deltaUUSCOREuprm_s1x + 2*deltaUprm_s1x*r
Lambprm_s1x = (a2*deltaT*xi2prm_s1x + a2*deltaTprm_s1x*xi2 + a2prm_s1x*deltaT*xi2 - 2*w2*w2prm_s1x)*sp.sign(a2*deltaT*xi2 - w2**2)
rho2xi2Lambprm_s1x = Lamb*rho2*xi2prm_s1x + Lamb*rho2prm_s1x*xi2 + Lambprm_s1x*rho2*xi2
invrho2xi2Lambprm_s1x = -rho2xi2Lambprm_s1x/rho2xi2Lamb**2
invrho2prm_s1x = -rho2prm_s1x/rho2**2
invxi2prm_s1x = -xi2prm_s1x/xi2**2
invLambprm_s1x = -Lambprm_s1x/Lamb**2
invLambsqprm_s1x = 2*invLamb*invLambprm_s1x
rho2invLambprm_s1x = invLamb*rho2prm_s1x + invLambprm_s1x*rho2
expnuprm_s1x = sp.sqrt(deltaT*rho2invLamb)*(deltaT*rho2invLambprm_s1x/2 + deltaTprm_s1x*rho2invLamb/2)/(deltaT*rho2invLamb)
expMUprm_s1x = rho2prm_s1x/(2*sp.sqrt(rho2))
expMUexpnuprm_s1x = expMU*expnuprm_s1x + expMUprm_s1x*expnu
expMUsqprm_s1x = 2*expMU*expMUprm_s1x
expnusqprm_s1x = 2*expnu*expnuprm_s1x
expMUsqexpnusqprm_s1x = expMUsq*expnusqprm_s1x + expMUsqprm_s1x*expnusq
invexpnuexpMUprm_s1x = -expMUexpnuprm_s1x/expMUexpnu**2
invexpMUprm_s1x = expnu*invexpnuexpMUprm_s1x + expnuprm_s1x*invexpnuexpMU
invexpMUsqprm_s1x = 2*invexpMU*invexpMUprm_s1x
expnuinvexpMU2prm_s1x = expnu*invexpMUsqprm_s1x + expnuprm_s1x*invexpMUsq
invexpMUcubinvexpnuprm_s1x = invexpMUsq*invexpnuexpMUprm_s1x + invexpMUsqprm_s1x*invexpnuexpMU
deltaRprm_s1x = DD*deltaTprm_s1x
wwprm_s1x = a*a2prm_s1x*b3*eta*u + a2*aprm_s1x*b3*eta*u + aprm_s1x*bb3*eta*u + 2*aprm_s1x*r
Bprm_s1x = deltaTprm_s1x/(2*sp.sqrt(deltaT))
sqrtdeltaTprm_s1x = Bprm_s1x
sqrtdeltaRprm_s1x = deltaRprm_s1x/(2*sp.sqrt(deltaR))
deltaTsqrtdeltaRprm_s1x = deltaT*sqrtdeltaRprm_s1x + deltaTprm_s1x*sqrtdeltaR
sqrtdeltaTdeltaTsqrtdeltaRprm_s1x = deltaTsqrtdeltaR*sqrtdeltaTprm_s1x + deltaTsqrtdeltaRprm_s1x*sqrtdeltaT
invdeltaTsqrtdeltaTsqrtdeltaRprm_s1x = -1.0*sqrtdeltaTdeltaTsqrtdeltaRprm_s1x/sqrtdeltaTdeltaTsqrtdeltaR**2
invdeltaTprm_s1x = invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaR*sqrtdeltaTprm_s1x + invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaRprm_s1x*sqrtdeltaT + invdeltaTsqrtdeltaTsqrtdeltaRprm_s1x*sqrtdeltaR*sqrtdeltaT
invsqrtdeltaTprm_s1x = deltaTsqrtdeltaR*invdeltaTsqrtdeltaTsqrtdeltaRprm_s1x + deltaTsqrtdeltaRprm_s1x*invdeltaTsqrtdeltaTsqrtdeltaR
invsqrtdeltaRprm_s1x = deltaT*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaTprm_s1x + deltaT*invdeltaTsqrtdeltaTsqrtdeltaRprm_s1x*sqrtdeltaT + deltaTprm_s1x*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaT
wprm_s1x = invLamb*wwprm_s1x + invLambprm_s1x*ww
LambUSCORErprm_s1x = -a2*deltaTUSCOREr*xi2prm_s1x - a2*deltaTUSCORErprm_s1x*xi2 - a2prm_s1x*deltaTUSCOREr*xi2 + 4*r*w2prm_s1x
wwUSCORErprm_s1x = -a*a2prm_s1x*b3*eta*u2 - a2*aprm_s1x*b3*eta*u2 - aprm_s1x*bb3*eta*u2 + 2*aprm_s1x
BRprm_s1x = invsqrtdeltaT*(-deltaT*invsqrtdeltaRprm_s1x + deltaTUSCORErprm_s1x/2 - deltaTprm_s1x*invsqrtdeltaR) + invsqrtdeltaTprm_s1x*(-deltaT*invsqrtdeltaR + deltaTUSCOREr/2)
wrprm_s1x = invLambsq*(Lamb*wwUSCORErprm_s1x - LambUSCOREr*wwprm_s1x - LambUSCORErprm_s1x*ww + Lambprm_s1x*wwUSCOREr) + invLambsqprm_s1x*(Lamb*wwUSCOREr - LambUSCOREr*ww)
nurpt2prm_s1x = w2*(deltaTUSCOREr*w2prm_s1x + deltaTUSCORErprm_s1x*w2 - 4.0*deltaTprm_s1x*r) + w2prm_s1x*(-4.0*deltaT*r + deltaTUSCOREr*w2)
nurpt1prm_s1x = invdeltaT*nurpt2prm_s1x + invdeltaTprm_s1x*nurpt2
nurprm_s1x = invLamb*nurpt1prm_s1x/2 + invLambprm_s1x*nurpt1/2 + invrho2prm_s1x*r
murprm_s1x = invrho2prm_s1x*r - invsqrtdeltaRprm_s1x
a2costhetaprm_s1x = a2*costhetaprm_s1x + a2prm_s1x*costheta
wcospt2prm_s1x = deltaT*wwprm_s1x + deltaTprm_s1x*ww
wcospt1prm_s1x = invLambsq*wcospt2prm_s1x + invLambsqprm_s1x*wcospt2
wcosprm_s1x = -2*a2costheta*wcospt1prm_s1x - 2*a2costhetaprm_s1x*wcospt1
nucospt3prm_s1x = invLamb*invrho2prm_s1x + invLambprm_s1x*invrho2
nucospt2prm_s1x = nucospt3*w2prm_s1x + nucospt3prm_s1x*w2
nucospt1prm_s1x = a2costheta*nucospt2prm_s1x + a2costhetaprm_s1x*nucospt2
nucosprm_s1x = nucospt1*(-deltaTprm_s1x + w2prm_s1x) + nucospt1prm_s1x*(-deltaT + w2)
mucosprm_s1x = a2costheta*invrho2prm_s1x + a2costhetaprm_s1x*invrho2
csiprm_s1x = (deltaR*deltaTprm_s1x + deltaRprm_s1x*deltaT)*sp.sign(deltaR*deltaT)/(2*w2*sp.sqrt(sp.Abs(deltaR*deltaT))) - w2prm_s1x*sp.sqrt(sp.Abs(deltaR*deltaT))/w2**2
csi1prm_s1x = csiprm_s1x*(1 - sp.Abs(tortoise - 1))
csi2prm_s1x = csiprm_s1x*(1/2 - 0.5*sp.sign(1.5 - tortoise))
prTprm_s1x = csi2prm_s1x*(nx*px + ny*py + nz*pz)
prTtimesoneminuscsi1invprm_s1x = prTprm_s1x*(1 - 1/csi1) + csi1prm_s1x*prT/csi1**2
tmppxprm_s1x = -nx*prTtimesoneminuscsi1invprm_s1x
tmppyprm_s1x = -ny*prTtimesoneminuscsi1invprm_s1x
tmppzprm_s1x = -nz*prTtimesoneminuscsi1invprm_s1x
pxirprm_s1x = r*(tmppx*xiUSCORExprm_s1x + tmppxprm_s1x*xiUSCOREx + tmppy*xiUSCOREyprm_s1x + tmppyprm_s1x*xiUSCOREy + tmppz*xiUSCOREzprm_s1x + tmppzprm_s1x*xiUSCOREz)
pvrprm_s1x = r*(tmppx*vxprm_s1x + tmppxprm_s1x*vx + tmppy*vyprm_s1x + tmppyprm_s1x*vy + tmppz*vzprm_s1x + tmppzprm_s1x*vz)
pvrsqprm_s1x = 2*pvr*pvrprm_s1x
pnprm_s1x = nx*tmppxprm_s1x + ny*tmppyprm_s1x + nz*tmppzprm_s1x
pnsqprm_s1x = 2*pn*pnprm_s1x
prprm_s1x = pnprm_s1x
prsqprm_s1x = 2*pr*prprm_s1x
pfprm_s1x = pxirprm_s1x
pxirsqprm_s1x = 2*pxir*pxirprm_s1x
ptheta2prm_s1x = invxi2*pvrsqprm_s1x + invxi2prm_s1x*pvrsq
prT4prm_s1x = 4*prT**3*prTprm_s1x
Hnspt7prm_s1x = deltaR*invrho2prm_s1x + deltaRprm_s1x*invrho2
Hnspt6prm_s1x = invxi2*rho2invLambprm_s1x + invxi2prm_s1x*rho2invLamb
Hnspt4prm_s1x = Hnspt5*prT4prm_s1x + 2*Hnspt6*pf*pfprm_s1x + Hnspt6prm_s1x*pf**2 + Hnspt7*prsqprm_s1x + Hnspt7prm_s1x*prsq + invrho2*ptheta2prm_s1x + invrho2prm_s1x*ptheta2
Hnspt3prm_s1x = Hnspt4*deltaTprm_s1x + Hnspt4prm_s1x*deltaT
Hnspt2prm_s1x = Hnspt3*rho2prm_s1x + Hnspt3prm_s1x*rho2
Hnspt1prm_s1x = pf*wwprm_s1x + pfprm_s1x*ww
Hnsprm_s1x = Hnspt1*invLambprm_s1x + Hnspt1prm_s1x*invLamb + sp.sqrt(Hnspt2*invLamb)*(Hnspt2*invLambprm_s1x/2 + Hnspt2prm_s1x*invLamb/2)/(Hnspt2*invLamb)
Qpt3prm_s1x = deltaR*invrho2prm_s1x + deltaRprm_s1x*invrho2
Qpt2prm_s1x = invxi2*rho2invLambprm_s1x + invxi2prm_s1x*rho2invLamb
Qpt1prm_s1x = invrho2*invxi2prm_s1x + invrho2prm_s1x*invxi2
Qprm_s1x = Qpt1*pvrsqprm_s1x + Qpt1prm_s1x*pvrsq + Qpt2*pxirsqprm_s1x + Qpt2prm_s1x*pxirsq + Qpt3*pnsqprm_s1x + Qpt3prm_s1x*pnsq
pn2prm_s1x = deltaR*invrho2*prsqprm_s1x + deltaR*invrho2prm_s1x*prsq + deltaRprm_s1x*invrho2*prsq
ppprm_s1x = Qprm_s1x
sKerrmultfactprm_s1x = r*(-36*pn2prm_s1x + 3*ppprm_s1x)
sStarmultfactprm_s1x = r*(-30*pn2prm_s1x + 4*ppprm_s1x)
deltaSigmaStarUSCOREx1prm_s1x = etaover12r*(sKerrUSCOREx*sKerrmultfactprm_s1x + sKerrUSCORExprm_s1x*sKerrmultfact + sStarUSCOREx*sStarmultfactprm_s1x + sStarUSCORExprm_s1x*sStarmultfact)
deltaSigmaStarUSCOREy1prm_s1x = etaover12r*(sKerrUSCOREy*sKerrmultfactprm_s1x + sStarUSCOREy*sStarmultfactprm_s1x)
deltaSigmaStarUSCOREz1prm_s1x = etaover12r*(sKerrUSCOREz*sKerrmultfactprm_s1x + sStarUSCOREz*sStarmultfactprm_s1x)
pn2ppprm_s1x = pn2*ppprm_s1x + pn2prm_s1x*pp
pp2prm_s1x = 2*pp*ppprm_s1x
pn2u2prm_s1x = pn2prm_s1x*u2
ppu2prm_s1x = ppprm_s1x*u2
pn2ppu2prm_s1x = pn2ppprm_s1x*u2
sMultiplier1pt6prm_s1x = -720*pn2*pn2prm_s1x + 126*pn2ppprm_s1x + 3*pp2prm_s1x
sMultiplier1pt5prm_s1x = -96*pn2ppprm_s1x + 23*pp2prm_s1x
sMultiplier1pt4prm_s1x = 324*pn2prm_s1x - 120*ppprm_s1x + r*sMultiplier1pt6prm_s1x
sMultiplier1pt3prm_s1x = -282*pn2prm_s1x + 206*ppprm_s1x + r*sMultiplier1pt5prm_s1x
sMultiplier1pt2prm_s1x = r*sMultiplier1pt4prm_s1x
sMultiplier1pt1prm_s1x = eta*sMultiplier1pt2prm_s1x + r*sMultiplier1pt3prm_s1x
sMultiplier1prm_s1x = -eta*sMultiplier1pt1prm_s1x*u2/72
sMultiplier2pt6prm_s1x = 45*pn2*pn2u2prm_s1x/8 - 13*pn2ppu2prm_s1x/8 + 45*pn2prm_s1x*pn2u2/8
sMultiplier2pt5prm_s1x = pn2ppu2prm_s1x/4 - 5*pp2prm_s1x*u2/16
sMultiplier2pt4prm_s1x = -49*pn2u2prm_s1x/8 + 17*ppu2prm_s1x/12 + r*sMultiplier2pt6prm_s1x
sMultiplier2pt3prm_s1x = -2*pn2u2prm_s1x/3 - 109*ppu2prm_s1x/36 + r*sMultiplier2pt5prm_s1x
sMultiplier2pt2prm_s1x = r*sMultiplier2pt4prm_s1x
sMultiplier2pt1prm_s1x = eta*sMultiplier2pt2prm_s1x + r*sMultiplier2pt3prm_s1x
sMultiplier2prm_s1x = eta*sMultiplier2pt1prm_s1x
deltaSigmaStarUSCOREx2prm_s1x = deltaSigmaStarUSCOREx1prm_s1x + sMultiplier1*sigmaStar0prm_s1x + sMultiplier1prm_s1x*sigmaStar0 + sMultiplier2*sigmaKerr0prm_s1x + sMultiplier2prm_s1x*sigmaKerr0
deltaSigmaStarUSCOREy2prm_s1x = deltaSigmaStarUSCOREy1prm_s1x + sMultiplier1prm_s1x*sigmaStar1 + sMultiplier2prm_s1x*sigmaKerr1
deltaSigmaStarUSCOREz2prm_s1x = deltaSigmaStarUSCOREz1prm_s1x + sMultiplier1prm_s1x*sigmaStar2 + sMultiplier2prm_s1x*sigmaKerr2
deltaSigmaStarUSCORExprm_s1x = d1v2*etau3*sigmaKerr0prm_s1x + deltaSigmaStarUSCOREx2prm_s1x
deltaSigmaStarUSCOREyprm_s1x = deltaSigmaStarUSCOREy2prm_s1x
deltaSigmaStarUSCOREzprm_s1x = deltaSigmaStarUSCOREz2prm_s1x
sxprm_s1x = deltaSigmaStarUSCORExprm_s1x + sStarUSCORExprm_s1x
syprm_s1x = deltaSigmaStarUSCOREyprm_s1x
szprm_s1x = deltaSigmaStarUSCOREzprm_s1x
sxiprm_s1x = sx*xiUSCORExprm_s1x + sxprm_s1x*xiUSCOREx + sy*xiUSCOREyprm_s1x + syprm_s1x*xiUSCOREy + sz*xiUSCOREzprm_s1x + szprm_s1x*xiUSCOREz
svprm_s1x = sx*vxprm_s1x + sxprm_s1x*vx + sy*vyprm_s1x + syprm_s1x*vy + sz*vzprm_s1x + szprm_s1x*vz
snprm_s1x = nx*sxprm_s1x + ny*syprm_s1x + nz*szprm_s1x
s3prm_s1x = e3USCOREx*sxprm_s1x + e3USCORExprm_s1x*sx + e3USCOREy*syprm_s1x + e3USCOREyprm_s1x*sy + e3USCOREz*szprm_s1x + e3USCOREzprm_s1x*sz
sqrtQprm_s1x = Qprm_s1x/(2*sp.sqrt(Q))
oneplus2sqrtQprm_s1x = 2*sqrtQprm_s1x
oneplus1sqrtQprm_s1x = oneplus2sqrtQprm_s1x - sqrtQprm_s1x
twoB1psqrtQsqrtQprm_s1x = 2*B*oneplus1sqrtQ*sqrtQprm_s1x + 2*B*oneplus1sqrtQprm_s1x*sqrtQ + 2*Bprm_s1x*oneplus1sqrtQ*sqrtQ
invtwoB1psqrtQsqrtQprm_s1x = -twoB1psqrtQsqrtQprm_s1x/twoB1psqrtQsqrtQ**2
expMUsqsqrtQplusQprm_s1x = expMUsq*(Qprm_s1x + sqrtQprm_s1x) + expMUsqprm_s1x*(Q + sqrtQ)
Hwrpt4aprm_s1x = pxirsq*svprm_s1x + pxirsqprm_s1x*sv
Hwrpt4prm_s1x = Hwrpt4a*expMUsqexpnusqprm_s1x + Hwrpt4aprm_s1x*expMUsqexpnusq
Hwrpt3cprm_s1x = pxir*sxiprm_s1x + pxirprm_s1x*sxi
Hwrpt3bprm_s1x = Hwrpt3c*pvrprm_s1x + Hwrpt3cprm_s1x*pvr
Hwrpt3aprm_s1x = Hwrpt3b*expMUexpnuprm_s1x + Hwrpt3bprm_s1x*expMUexpnu
Hwrpt3prm_s1x = B*Hwrpt3aprm_s1x + Bprm_s1x*Hwrpt3a
Hwrpt2gprm_s1x = deltaR*svprm_s1x + deltaRprm_s1x*sv
Hwrpt2fprm_s1x = sn*sqrtdeltaRprm_s1x + snprm_s1x*sqrtdeltaR
Hwrpt2eprm_s1x = Hwrpt2f*pvrprm_s1x + Hwrpt2fprm_s1x*pvr
Hwrpt2dprm_s1x = Hwrpt2g*pnsqprm_s1x + Hwrpt2gprm_s1x*pnsq
Hwrpt2cprm_s1x = Hwrpt2e*pnprm_s1x + Hwrpt2eprm_s1x*pn
Hwrpt2bprm_s1x = expMUsqsqrtQplusQ*svprm_s1x + expMUsqsqrtQplusQprm_s1x*sv
Hwrpt2aprm_s1x = xi2*(Hwrpt2bprm_s1x + Hwrpt2cprm_s1x - Hwrpt2dprm_s1x) + xi2prm_s1x*(Hwrpt2b + Hwrpt2c - Hwrpt2d)
Hwrpt2prm_s1x = Hwrpt2a*deltaTprm_s1x + Hwrpt2aprm_s1x*deltaT
Hwrpt1bprm_s1x = invtwoB1psqrtQsqrtQ*invxi2prm_s1x + invtwoB1psqrtQsqrtQprm_s1x*invxi2
Hwrpt1aprm_s1x = Hwrpt1b*sqrtdeltaRprm_s1x + Hwrpt1bprm_s1x*sqrtdeltaR
Hwrpt1prm_s1x = Hwrpt1a*invexpMUcubinvexpnuprm_s1x + Hwrpt1aprm_s1x*invexpMUcubinvexpnu
Hwrprm_s1x = Hwrpt1*(Hwrpt2prm_s1x - Hwrpt3prm_s1x + Hwrpt4prm_s1x) + Hwrpt1prm_s1x*(Hwrpt2 - Hwrpt3 + Hwrpt4)
Hwcospt9prm_s1x = pxir*sxiprm_s1x + pxirprm_s1x*sxi
Hwcospt8prm_s1x = pvr*svprm_s1x + pvrprm_s1x*sv
Hwcospt7prm_s1x = B*Hwcospt8prm_s1x + Bprm_s1x*Hwcospt8 - Hwcospt9*expMUexpnuprm_s1x - Hwcospt9prm_s1x*expMUexpnu
Hwcospt6prm_s1x = Hwcospt7*sqrtdeltaRprm_s1x + Hwcospt7prm_s1x*sqrtdeltaR
Hwcospt5prm_s1x = -expMUsqsqrtQplusQ*xi2prm_s1x - expMUsqsqrtQplusQprm_s1x*xi2 + pvrsqprm_s1x
Hwcospt4prm_s1x = Hwcospt6*pnprm_s1x + Hwcospt6prm_s1x*pn
Hwcospt3prm_s1x = Hwcospt5*deltaTprm_s1x + Hwcospt5prm_s1x*deltaT - expMUsqexpnusq*pxirsqprm_s1x - expMUsqexpnusqprm_s1x*pxirsq
Hwcospt2prm_s1x = -B*Hwcospt4prm_s1x - Bprm_s1x*Hwcospt4 + Hwcospt3*snprm_s1x + Hwcospt3prm_s1x*sn
Hwcospt1prm_s1x = Hwcospt2*invexpMUcubinvexpnuprm_s1x + Hwcospt2prm_s1x*invexpMUcubinvexpnu
Hwcosprm_s1x = Hwcospt1*invtwoB1psqrtQsqrtQprm_s1x + Hwcospt1prm_s1x*invtwoB1psqrtQsqrtQ
deltaTsqrtQprm_s1x = deltaT*sqrtQprm_s1x + deltaTprm_s1x*sqrtQ
invdeltatTsqrtQprm_s1x = -deltaTsqrtQprm_s1x/deltaTsqrtQ**2
HSOLpt5prm_s1x = pxir*(-Bprm_s1x + expMUexpnuprm_s1x) + pxirprm_s1x*(-B + expMUexpnu)
HSOLpt4prm_s1x = HSOLpt5*invexpMUprm_s1x + HSOLpt5prm_s1x*invexpMU
HSOLpt3prm_s1x = HSOLpt4*expnusqprm_s1x + HSOLpt4prm_s1x*expnusq
HSOLpt2prm_s1x = HSOLpt3*s3prm_s1x + HSOLpt3prm_s1x*s3
HSOLpt1prm_s1x = HSOLpt2*invxi2prm_s1x + HSOLpt2prm_s1x*invxi2
HSOLprm_s1x = HSOLpt1*invdeltatTsqrtQprm_s1x + HSOLpt1prm_s1x*invdeltatTsqrtQ
deltaTsqrtQplusQprm_s1x = deltaT*(Qprm_s1x + sqrtQprm_s1x) + deltaTprm_s1x*(Q + sqrtQ)
invdeltaTsqrtQplusQprm_s1x = -deltaTsqrtQplusQprm_s1x/deltaTsqrtQplusQ**2
HSONLmult2prm_s1x = invdeltaTsqrtQplusQ*invxi2prm_s1x + invdeltaTsqrtQplusQprm_s1x*invxi2
HSONLmultprm_s1x = HSONLmult2*expnuinvexpMU2prm_s1x + HSONLmult2prm_s1x*expnuinvexpMU2
HSONLpt1bprm_s1x = pn*xi2prm_s1x + pnprm_s1x*xi2
HSONLpt1aprm_s1x = HSONLpt1b*(-mucosprm_s1x + nucosprm_s1x) + HSONLpt1bprm_s1x*(-mucos + nucos) + mur*pvrprm_s1x + murprm_s1x*pvr - nur*pvrprm_s1x - nurprm_s1x*pvr
HSONLpt1prm_s1x = HSONLpt1a*sqrtQprm_s1x + HSONLpt1aprm_s1x*sqrtQ - HSONLpt1b*mucosprm_s1x - HSONLpt1bprm_s1x*mucos + mur*pvrprm_s1x + murprm_s1x*pvr
HSONLpt2dprm_s1x = nur*pxirprm_s1x + nurprm_s1x*pxir
HSONLpt2cprm_s1x = HSONLpt2d*oneplus2sqrtQprm_s1x + HSONLpt2dprm_s1x*oneplus2sqrtQ
HSONLpt2bprm_s1x = B*sxiprm_s1x + Bprm_s1x*sxi
HSONLpt2aprm_s1x = HSONLpt2c*expMUexpnuprm_s1x + HSONLpt2cprm_s1x*expMUexpnu
HSONLpt2prm_s1x = HSONLpt1*HSONLpt2bprm_s1x + HSONLpt1prm_s1x*HSONLpt2b + HSONLpt2a*svprm_s1x + HSONLpt2aprm_s1x*sv
HSONLpt3cprm_s1x = pxir*svprm_s1x + pxirprm_s1x*sv
HSONLpt3bprm_s1x = HSONLpt3c*oneplus1sqrtQprm_s1x + HSONLpt3cprm_s1x*oneplus1sqrtQ
HSONLpt3aprm_s1x = HSONLpt3b*expMUexpnuprm_s1x + HSONLpt3bprm_s1x*expMUexpnu
HSONLpt3prm_s1x = B*HSONLpt2prm_s1x - BR*HSONLpt3aprm_s1x - BRprm_s1x*HSONLpt3a + Bprm_s1x*HSONLpt2
HSONLpt4eprm_s1x = sn*xi2prm_s1x + snprm_s1x*xi2
HSONLpt4dprm_s1x = HSONLpt4e*oneplus2sqrtQprm_s1x + HSONLpt4eprm_s1x*oneplus2sqrtQ
HSONLpt4cprm_s1x = HSONLpt4d*pxirprm_s1x + HSONLpt4dprm_s1x*pxir
HSONLpt4bprm_s1x = HSONLpt4c*nucosprm_s1x + HSONLpt4cprm_s1x*nucos
HSONLpt4aprm_s1x = HSONLpt4b*expMUexpnuprm_s1x + HSONLpt4bprm_s1x*expMUexpnu
HSONLpt4prm_s1x = -B*HSONLpt4aprm_s1x - Bprm_s1x*HSONLpt4a + HSONLpt3*sqrtdeltaRprm_s1x + HSONLpt3prm_s1x*sqrtdeltaR
HSONLprm_s1x = HSONLmult*HSONLpt4prm_s1x + HSONLmultprm_s1x*HSONLpt4
Hsprm_s1x = HSOLprm_s1x + HSONLprm_s1x + Hwcos*wcosprm_s1x + Hwcosprm_s1x*wcos + Hwr*wrprm_s1x + Hwrprm_s1x*wr + s3*wprm_s1x + s3prm_s1x*w
Hsspt1prm_s1x = 3*sn*snprm_s1x - sx*sxprm_s1x - sy*syprm_s1x - sz*szprm_s1x
Hssprm_s1x = Hsspt1prm_s1x*u3
sKerrdotsStarprm_s1x = sKerrUSCOREx*sStarUSCORExprm_s1x + sKerrUSCORExprm_s1x*sStarUSCOREx
Hpt1prm_s1x = etau4*s1dots1prm_s1x
Hprm_s1x = Hnsprm_s1x + Hpt1prm_s1x*dheffSSv2 + Hsprm_s1x + Hssprm_s1x
Hrealprm_s1x = Hprm_s1x*eta*sp.sign(H)/sp.sqrt(2*eta*(sp.Abs(H) - 1) + 1)
sigmaKerr1prm_s1y = 1
sigmaStar1prm_s1y = m2overm1
s1dots1prm_s1y = 2*s1y
sKerrUSCOREyprm_s1y = sigmaKerr1prm_s1y
sStarUSCOREyprm_s1y = sigmaStar1prm_s1y
a2prm_s1y = 2*sKerrUSCOREy*sKerrUSCOREyprm_s1y
a4prm_s1y = 2*a2*a2prm_s1y
aprm_s1y = a2prm_s1y/(2*sp.sqrt(a2))
invaprm_s1y = -aprm_s1y/a**2
k2prm_s1y = -a2prm_s1y*k0*m1PlusetaKKsq
k2sqprm_s1y = 2*k2*k2prm_s1y
k3prm_s1y = -a2prm_s1y*k1*m1PlusetaKKsq + k1*k2prm_s1y - 2.0*k2prm_s1y*m1PlusetaKK
k4prm_s1y = -1.0*a2*k2prm_s1y*m1PlusetaKKsq + a2prm_s1y*m1PlusetaKKsq*(0.5*k1sq - 1.0*k2) + 0.0833333333333333*k1*(24*k2prm_s1y*m1PlusetaKK + 12*k3prm_s1y) - 1.0*k1sq*k2prm_s1y + 1.0*k2*k2prm_s1y - 2.0*k3prm_s1y*m1PlusetaKK
k5prm_s1y = m1PlusetaKKsq*(a2*(1.0*k1*k2prm_s1y - 1.0*k3prm_s1y) + a2prm_s1y*(1.0*k1*k2 - 0.333333333333333*k1cu - 1.0*k3) - (1.0*k1*k2sqprm_s1y - 1.0*k1*k4prm_s1y - 1.0*k1cu*k2prm_s1y + 1.0*k1sq*k3prm_s1y - 1.0*k2*k3prm_s1y - 1.0*k2prm_s1y*k3)/m1PlusetaKKsq + (4.0*k1*k3prm_s1y - 4.0*k1sq*k2prm_s1y + 2.0*k2sqprm_s1y - 4.0*k4prm_s1y)/(2*m1PlusetaKK))
e3USCORExprm_s1y = invaprm_s1y*sKerrUSCOREx
e3USCOREyprm_s1y = inva*sKerrUSCOREyprm_s1y + invaprm_s1y*sKerrUSCOREy
e3USCOREzprm_s1y = invaprm_s1y*sKerrUSCOREz
costhetaprm_s1y = e3USCORExprm_s1y*nx + e3USCOREyprm_s1y*ny + e3USCOREzprm_s1y*nz
xi2prm_s1y = -2*costheta*costhetaprm_s1y
xiUSCORExprm_s1y = e3USCOREyprm_s1y*nz - e3USCOREzprm_s1y*ny
xiUSCOREyprm_s1y = -e3USCORExprm_s1y*nz + e3USCOREzprm_s1y*nx
xiUSCOREzprm_s1y = e3USCORExprm_s1y*ny - e3USCOREyprm_s1y*nx
vxprm_s1y = ny*xiUSCOREzprm_s1y - nz*xiUSCOREyprm_s1y
vyprm_s1y = -nx*xiUSCOREzprm_s1y + nz*xiUSCORExprm_s1y
vzprm_s1y = nx*xiUSCOREyprm_s1y - ny*xiUSCORExprm_s1y
w2prm_s1y = a2prm_s1y
rho2prm_s1y = 2*a2*costheta*costhetaprm_s1y + a2prm_s1y*costheta**2
bulkprm_s1y = a2prm_s1y*u2
logargprm_s1y = k2prm_s1y*u2 + k3prm_s1y*u3 + k4prm_s1y*u4 + k5prm_s1y*u5
onepluslogargprm_s1y = logargprm_s1y
invonepluslogargprm_s1y = -onepluslogargprm_s1y/onepluslogarg**2
logTermsprm_s1y = eta*onepluslogargprm_s1y*sp.sign(onepluslogarg)/sp.Abs(onepluslogarg)
deltaUprm_s1y = (bulk*logTermsprm_s1y + bulkprm_s1y*logTerms)*sp.sign(bulk*logTerms)
deltaTprm_s1y = deltaUprm_s1y*r2
deltaUUSCOREupt7prm_s1y = k5prm_s1y
deltaUUSCOREupt6prm_s1y = 5*deltaUUSCOREupt7prm_s1y*u + 4*k4prm_s1y
deltaUUSCOREupt5prm_s1y = deltaUUSCOREupt6prm_s1y*u + 3*k3prm_s1y
deltaUUSCOREupt4prm_s1y = deltaUUSCOREupt5prm_s1y*u + 2*k2prm_s1y
deltaUUSCOREupt3prm_s1y = deltaUUSCOREupt4prm_s1y*u
deltaUUSCOREupt2prm_s1y = a2prm_s1y*u
deltaUUSCOREupt1prm_s1y = bulk*deltaUUSCOREupt3prm_s1y*eta + bulkprm_s1y*deltaUUSCOREupt3*eta
deltaUUSCOREuprm_s1y = deltaUUSCOREupt1*invonepluslogargprm_s1y + deltaUUSCOREupt1prm_s1y*invonepluslogarg + 2*deltaUUSCOREupt2*logTermsprm_s1y + 2*deltaUUSCOREupt2prm_s1y*logTerms
deltaTUSCORErprm_s1y = -deltaUUSCOREuprm_s1y + 2*deltaUprm_s1y*r
Lambprm_s1y = (a2*deltaT*xi2prm_s1y + a2*deltaTprm_s1y*xi2 + a2prm_s1y*deltaT*xi2 - 2*w2*w2prm_s1y)*sp.sign(a2*deltaT*xi2 - w2**2)
rho2xi2Lambprm_s1y = Lamb*rho2*xi2prm_s1y + Lamb*rho2prm_s1y*xi2 + Lambprm_s1y*rho2*xi2
invrho2xi2Lambprm_s1y = -rho2xi2Lambprm_s1y/rho2xi2Lamb**2
invrho2prm_s1y = -rho2prm_s1y/rho2**2
invxi2prm_s1y = -xi2prm_s1y/xi2**2
invLambprm_s1y = -Lambprm_s1y/Lamb**2
invLambsqprm_s1y = 2*invLamb*invLambprm_s1y
rho2invLambprm_s1y = invLamb*rho2prm_s1y + invLambprm_s1y*rho2
expnuprm_s1y = sp.sqrt(deltaT*rho2invLamb)*(deltaT*rho2invLambprm_s1y/2 + deltaTprm_s1y*rho2invLamb/2)/(deltaT*rho2invLamb)
expMUprm_s1y = rho2prm_s1y/(2*sp.sqrt(rho2))
expMUexpnuprm_s1y = expMU*expnuprm_s1y + expMUprm_s1y*expnu
expMUsqprm_s1y = 2*expMU*expMUprm_s1y
expnusqprm_s1y = 2*expnu*expnuprm_s1y
expMUsqexpnusqprm_s1y = expMUsq*expnusqprm_s1y + expMUsqprm_s1y*expnusq
invexpnuexpMUprm_s1y = -expMUexpnuprm_s1y/expMUexpnu**2
invexpMUprm_s1y = expnu*invexpnuexpMUprm_s1y + expnuprm_s1y*invexpnuexpMU
invexpMUsqprm_s1y = 2*invexpMU*invexpMUprm_s1y
expnuinvexpMU2prm_s1y = expnu*invexpMUsqprm_s1y + expnuprm_s1y*invexpMUsq
invexpMUcubinvexpnuprm_s1y = invexpMUsq*invexpnuexpMUprm_s1y + invexpMUsqprm_s1y*invexpnuexpMU
deltaRprm_s1y = DD*deltaTprm_s1y
wwprm_s1y = a*a2prm_s1y*b3*eta*u + a2*aprm_s1y*b3*eta*u + aprm_s1y*bb3*eta*u + 2*aprm_s1y*r
Bprm_s1y = deltaTprm_s1y/(2*sp.sqrt(deltaT))
sqrtdeltaTprm_s1y = Bprm_s1y
sqrtdeltaRprm_s1y = deltaRprm_s1y/(2*sp.sqrt(deltaR))
deltaTsqrtdeltaRprm_s1y = deltaT*sqrtdeltaRprm_s1y + deltaTprm_s1y*sqrtdeltaR
sqrtdeltaTdeltaTsqrtdeltaRprm_s1y = deltaTsqrtdeltaR*sqrtdeltaTprm_s1y + deltaTsqrtdeltaRprm_s1y*sqrtdeltaT
invdeltaTsqrtdeltaTsqrtdeltaRprm_s1y = -1.0*sqrtdeltaTdeltaTsqrtdeltaRprm_s1y/sqrtdeltaTdeltaTsqrtdeltaR**2
invdeltaTprm_s1y = invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaR*sqrtdeltaTprm_s1y + invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaRprm_s1y*sqrtdeltaT + invdeltaTsqrtdeltaTsqrtdeltaRprm_s1y*sqrtdeltaR*sqrtdeltaT
invsqrtdeltaTprm_s1y = deltaTsqrtdeltaR*invdeltaTsqrtdeltaTsqrtdeltaRprm_s1y + deltaTsqrtdeltaRprm_s1y*invdeltaTsqrtdeltaTsqrtdeltaR
invsqrtdeltaRprm_s1y = deltaT*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaTprm_s1y + deltaT*invdeltaTsqrtdeltaTsqrtdeltaRprm_s1y*sqrtdeltaT + deltaTprm_s1y*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaT
wprm_s1y = invLamb*wwprm_s1y + invLambprm_s1y*ww
LambUSCORErprm_s1y = -a2*deltaTUSCOREr*xi2prm_s1y - a2*deltaTUSCORErprm_s1y*xi2 - a2prm_s1y*deltaTUSCOREr*xi2 + 4*r*w2prm_s1y
wwUSCORErprm_s1y = -a*a2prm_s1y*b3*eta*u2 - a2*aprm_s1y*b3*eta*u2 - aprm_s1y*bb3*eta*u2 + 2*aprm_s1y
BRprm_s1y = invsqrtdeltaT*(-deltaT*invsqrtdeltaRprm_s1y + deltaTUSCORErprm_s1y/2 - deltaTprm_s1y*invsqrtdeltaR) + invsqrtdeltaTprm_s1y*(-deltaT*invsqrtdeltaR + deltaTUSCOREr/2)
wrprm_s1y = invLambsq*(Lamb*wwUSCORErprm_s1y - LambUSCOREr*wwprm_s1y - LambUSCORErprm_s1y*ww + Lambprm_s1y*wwUSCOREr) + invLambsqprm_s1y*(Lamb*wwUSCOREr - LambUSCOREr*ww)
nurpt2prm_s1y = w2*(deltaTUSCOREr*w2prm_s1y + deltaTUSCORErprm_s1y*w2 - 4.0*deltaTprm_s1y*r) + w2prm_s1y*(-4.0*deltaT*r + deltaTUSCOREr*w2)
nurpt1prm_s1y = invdeltaT*nurpt2prm_s1y + invdeltaTprm_s1y*nurpt2
nurprm_s1y = invLamb*nurpt1prm_s1y/2 + invLambprm_s1y*nurpt1/2 + invrho2prm_s1y*r
murprm_s1y = invrho2prm_s1y*r - invsqrtdeltaRprm_s1y
a2costhetaprm_s1y = a2*costhetaprm_s1y + a2prm_s1y*costheta
wcospt2prm_s1y = deltaT*wwprm_s1y + deltaTprm_s1y*ww
wcospt1prm_s1y = invLambsq*wcospt2prm_s1y + invLambsqprm_s1y*wcospt2
wcosprm_s1y = -2*a2costheta*wcospt1prm_s1y - 2*a2costhetaprm_s1y*wcospt1
nucospt3prm_s1y = invLamb*invrho2prm_s1y + invLambprm_s1y*invrho2
nucospt2prm_s1y = nucospt3*w2prm_s1y + nucospt3prm_s1y*w2
nucospt1prm_s1y = a2costheta*nucospt2prm_s1y + a2costhetaprm_s1y*nucospt2
nucosprm_s1y = nucospt1*(-deltaTprm_s1y + w2prm_s1y) + nucospt1prm_s1y*(-deltaT + w2)
mucosprm_s1y = a2costheta*invrho2prm_s1y + a2costhetaprm_s1y*invrho2
csiprm_s1y = (deltaR*deltaTprm_s1y + deltaRprm_s1y*deltaT)*sp.sign(deltaR*deltaT)/(2*w2*sp.sqrt(sp.Abs(deltaR*deltaT))) - w2prm_s1y*sp.sqrt(sp.Abs(deltaR*deltaT))/w2**2
csi1prm_s1y = csiprm_s1y*(1 - sp.Abs(tortoise - 1))
csi2prm_s1y = csiprm_s1y*(1/2 - 0.5*sp.sign(1.5 - tortoise))
prTprm_s1y = csi2prm_s1y*(nx*px + ny*py + nz*pz)
prTtimesoneminuscsi1invprm_s1y = prTprm_s1y*(1 - 1/csi1) + csi1prm_s1y*prT/csi1**2
tmppxprm_s1y = -nx*prTtimesoneminuscsi1invprm_s1y
tmppyprm_s1y = -ny*prTtimesoneminuscsi1invprm_s1y
tmppzprm_s1y = -nz*prTtimesoneminuscsi1invprm_s1y
pxirprm_s1y = r*(tmppx*xiUSCORExprm_s1y + tmppxprm_s1y*xiUSCOREx + tmppy*xiUSCOREyprm_s1y + tmppyprm_s1y*xiUSCOREy + tmppz*xiUSCOREzprm_s1y + tmppzprm_s1y*xiUSCOREz)
pvrprm_s1y = r*(tmppx*vxprm_s1y + tmppxprm_s1y*vx + tmppy*vyprm_s1y + tmppyprm_s1y*vy + tmppz*vzprm_s1y + tmppzprm_s1y*vz)
pvrsqprm_s1y = 2*pvr*pvrprm_s1y
pnprm_s1y = nx*tmppxprm_s1y + ny*tmppyprm_s1y + nz*tmppzprm_s1y
pnsqprm_s1y = 2*pn*pnprm_s1y
prprm_s1y = pnprm_s1y
prsqprm_s1y = 2*pr*prprm_s1y
pfprm_s1y = pxirprm_s1y
pxirsqprm_s1y = 2*pxir*pxirprm_s1y
ptheta2prm_s1y = invxi2*pvrsqprm_s1y + invxi2prm_s1y*pvrsq
prT4prm_s1y = 4*prT**3*prTprm_s1y
Hnspt7prm_s1y = deltaR*invrho2prm_s1y + deltaRprm_s1y*invrho2
Hnspt6prm_s1y = invxi2*rho2invLambprm_s1y + invxi2prm_s1y*rho2invLamb
Hnspt4prm_s1y = Hnspt5*prT4prm_s1y + 2*Hnspt6*pf*pfprm_s1y + Hnspt6prm_s1y*pf**2 + Hnspt7*prsqprm_s1y + Hnspt7prm_s1y*prsq + invrho2*ptheta2prm_s1y + invrho2prm_s1y*ptheta2
Hnspt3prm_s1y = Hnspt4*deltaTprm_s1y + Hnspt4prm_s1y*deltaT
Hnspt2prm_s1y = Hnspt3*rho2prm_s1y + Hnspt3prm_s1y*rho2
Hnspt1prm_s1y = pf*wwprm_s1y + pfprm_s1y*ww
Hnsprm_s1y = Hnspt1*invLambprm_s1y + Hnspt1prm_s1y*invLamb + sp.sqrt(Hnspt2*invLamb)*(Hnspt2*invLambprm_s1y/2 + Hnspt2prm_s1y*invLamb/2)/(Hnspt2*invLamb)
Qpt3prm_s1y = deltaR*invrho2prm_s1y + deltaRprm_s1y*invrho2
Qpt2prm_s1y = invxi2*rho2invLambprm_s1y + invxi2prm_s1y*rho2invLamb
Qpt1prm_s1y = invrho2*invxi2prm_s1y + invrho2prm_s1y*invxi2
Qprm_s1y = Qpt1*pvrsqprm_s1y + Qpt1prm_s1y*pvrsq + Qpt2*pxirsqprm_s1y + Qpt2prm_s1y*pxirsq + Qpt3*pnsqprm_s1y + Qpt3prm_s1y*pnsq
pn2prm_s1y = deltaR*invrho2*prsqprm_s1y + deltaR*invrho2prm_s1y*prsq + deltaRprm_s1y*invrho2*prsq
ppprm_s1y = Qprm_s1y
sKerrmultfactprm_s1y = r*(-36*pn2prm_s1y + 3*ppprm_s1y)
sStarmultfactprm_s1y = r*(-30*pn2prm_s1y + 4*ppprm_s1y)
deltaSigmaStarUSCOREx1prm_s1y = etaover12r*(sKerrUSCOREx*sKerrmultfactprm_s1y + sStarUSCOREx*sStarmultfactprm_s1y)
deltaSigmaStarUSCOREy1prm_s1y = etaover12r*(sKerrUSCOREy*sKerrmultfactprm_s1y + sKerrUSCOREyprm_s1y*sKerrmultfact + sStarUSCOREy*sStarmultfactprm_s1y + sStarUSCOREyprm_s1y*sStarmultfact)
deltaSigmaStarUSCOREz1prm_s1y = etaover12r*(sKerrUSCOREz*sKerrmultfactprm_s1y + sStarUSCOREz*sStarmultfactprm_s1y)
pn2ppprm_s1y = pn2*ppprm_s1y + pn2prm_s1y*pp
pp2prm_s1y = 2*pp*ppprm_s1y
pn2u2prm_s1y = pn2prm_s1y*u2
ppu2prm_s1y = ppprm_s1y*u2
pn2ppu2prm_s1y = pn2ppprm_s1y*u2
sMultiplier1pt6prm_s1y = -720*pn2*pn2prm_s1y + 126*pn2ppprm_s1y + 3*pp2prm_s1y
sMultiplier1pt5prm_s1y = -96*pn2ppprm_s1y + 23*pp2prm_s1y
sMultiplier1pt4prm_s1y = 324*pn2prm_s1y - 120*ppprm_s1y + r*sMultiplier1pt6prm_s1y
sMultiplier1pt3prm_s1y = -282*pn2prm_s1y + 206*ppprm_s1y + r*sMultiplier1pt5prm_s1y
sMultiplier1pt2prm_s1y = r*sMultiplier1pt4prm_s1y
sMultiplier1pt1prm_s1y = eta*sMultiplier1pt2prm_s1y + r*sMultiplier1pt3prm_s1y
sMultiplier1prm_s1y = -eta*sMultiplier1pt1prm_s1y*u2/72
sMultiplier2pt6prm_s1y = 45*pn2*pn2u2prm_s1y/8 - 13*pn2ppu2prm_s1y/8 + 45*pn2prm_s1y*pn2u2/8
sMultiplier2pt5prm_s1y = pn2ppu2prm_s1y/4 - 5*pp2prm_s1y*u2/16
sMultiplier2pt4prm_s1y = -49*pn2u2prm_s1y/8 + 17*ppu2prm_s1y/12 + r*sMultiplier2pt6prm_s1y
sMultiplier2pt3prm_s1y = -2*pn2u2prm_s1y/3 - 109*ppu2prm_s1y/36 + r*sMultiplier2pt5prm_s1y
sMultiplier2pt2prm_s1y = r*sMultiplier2pt4prm_s1y
sMultiplier2pt1prm_s1y = eta*sMultiplier2pt2prm_s1y + r*sMultiplier2pt3prm_s1y
sMultiplier2prm_s1y = eta*sMultiplier2pt1prm_s1y
deltaSigmaStarUSCOREx2prm_s1y = deltaSigmaStarUSCOREx1prm_s1y + sMultiplier1prm_s1y*sigmaStar0 + sMultiplier2prm_s1y*sigmaKerr0
deltaSigmaStarUSCOREy2prm_s1y = deltaSigmaStarUSCOREy1prm_s1y + sMultiplier1*sigmaStar1prm_s1y + sMultiplier1prm_s1y*sigmaStar1 + sMultiplier2*sigmaKerr1prm_s1y + sMultiplier2prm_s1y*sigmaKerr1
deltaSigmaStarUSCOREz2prm_s1y = deltaSigmaStarUSCOREz1prm_s1y + sMultiplier1prm_s1y*sigmaStar2 + sMultiplier2prm_s1y*sigmaKerr2
deltaSigmaStarUSCORExprm_s1y = deltaSigmaStarUSCOREx2prm_s1y
deltaSigmaStarUSCOREyprm_s1y = d1v2*etau3*sigmaKerr1prm_s1y + deltaSigmaStarUSCOREy2prm_s1y
deltaSigmaStarUSCOREzprm_s1y = deltaSigmaStarUSCOREz2prm_s1y
sxprm_s1y = deltaSigmaStarUSCORExprm_s1y
syprm_s1y = deltaSigmaStarUSCOREyprm_s1y + sStarUSCOREyprm_s1y
szprm_s1y = deltaSigmaStarUSCOREzprm_s1y
sxiprm_s1y = sx*xiUSCORExprm_s1y + sxprm_s1y*xiUSCOREx + sy*xiUSCOREyprm_s1y + syprm_s1y*xiUSCOREy + sz*xiUSCOREzprm_s1y + szprm_s1y*xiUSCOREz
svprm_s1y = sx*vxprm_s1y + sxprm_s1y*vx + sy*vyprm_s1y + syprm_s1y*vy + sz*vzprm_s1y + szprm_s1y*vz
snprm_s1y = nx*sxprm_s1y + ny*syprm_s1y + nz*szprm_s1y
s3prm_s1y = e3USCOREx*sxprm_s1y + e3USCORExprm_s1y*sx + e3USCOREy*syprm_s1y + e3USCOREyprm_s1y*sy + e3USCOREz*szprm_s1y + e3USCOREzprm_s1y*sz
sqrtQprm_s1y = Qprm_s1y/(2*sp.sqrt(Q))
oneplus2sqrtQprm_s1y = 2*sqrtQprm_s1y
oneplus1sqrtQprm_s1y = oneplus2sqrtQprm_s1y - sqrtQprm_s1y
twoB1psqrtQsqrtQprm_s1y = 2*B*oneplus1sqrtQ*sqrtQprm_s1y + 2*B*oneplus1sqrtQprm_s1y*sqrtQ + 2*Bprm_s1y*oneplus1sqrtQ*sqrtQ
invtwoB1psqrtQsqrtQprm_s1y = -twoB1psqrtQsqrtQprm_s1y/twoB1psqrtQsqrtQ**2
expMUsqsqrtQplusQprm_s1y = expMUsq*(Qprm_s1y + sqrtQprm_s1y) + expMUsqprm_s1y*(Q + sqrtQ)
Hwrpt4aprm_s1y = pxirsq*svprm_s1y + pxirsqprm_s1y*sv
Hwrpt4prm_s1y = Hwrpt4a*expMUsqexpnusqprm_s1y + Hwrpt4aprm_s1y*expMUsqexpnusq
Hwrpt3cprm_s1y = pxir*sxiprm_s1y + pxirprm_s1y*sxi
Hwrpt3bprm_s1y = Hwrpt3c*pvrprm_s1y + Hwrpt3cprm_s1y*pvr
Hwrpt3aprm_s1y = Hwrpt3b*expMUexpnuprm_s1y + Hwrpt3bprm_s1y*expMUexpnu
Hwrpt3prm_s1y = B*Hwrpt3aprm_s1y + Bprm_s1y*Hwrpt3a
Hwrpt2gprm_s1y = deltaR*svprm_s1y + deltaRprm_s1y*sv
Hwrpt2fprm_s1y = sn*sqrtdeltaRprm_s1y + snprm_s1y*sqrtdeltaR
Hwrpt2eprm_s1y = Hwrpt2f*pvrprm_s1y + Hwrpt2fprm_s1y*pvr
Hwrpt2dprm_s1y = Hwrpt2g*pnsqprm_s1y + Hwrpt2gprm_s1y*pnsq
Hwrpt2cprm_s1y = Hwrpt2e*pnprm_s1y + Hwrpt2eprm_s1y*pn
Hwrpt2bprm_s1y = expMUsqsqrtQplusQ*svprm_s1y + expMUsqsqrtQplusQprm_s1y*sv
Hwrpt2aprm_s1y = xi2*(Hwrpt2bprm_s1y + Hwrpt2cprm_s1y - Hwrpt2dprm_s1y) + xi2prm_s1y*(Hwrpt2b + Hwrpt2c - Hwrpt2d)
Hwrpt2prm_s1y = Hwrpt2a*deltaTprm_s1y + Hwrpt2aprm_s1y*deltaT
Hwrpt1bprm_s1y = invtwoB1psqrtQsqrtQ*invxi2prm_s1y + invtwoB1psqrtQsqrtQprm_s1y*invxi2
Hwrpt1aprm_s1y = Hwrpt1b*sqrtdeltaRprm_s1y + Hwrpt1bprm_s1y*sqrtdeltaR
Hwrpt1prm_s1y = Hwrpt1a*invexpMUcubinvexpnuprm_s1y + Hwrpt1aprm_s1y*invexpMUcubinvexpnu
Hwrprm_s1y = Hwrpt1*(Hwrpt2prm_s1y - Hwrpt3prm_s1y + Hwrpt4prm_s1y) + Hwrpt1prm_s1y*(Hwrpt2 - Hwrpt3 + Hwrpt4)
Hwcospt9prm_s1y = pxir*sxiprm_s1y + pxirprm_s1y*sxi
Hwcospt8prm_s1y = pvr*svprm_s1y + pvrprm_s1y*sv
Hwcospt7prm_s1y = B*Hwcospt8prm_s1y + Bprm_s1y*Hwcospt8 - Hwcospt9*expMUexpnuprm_s1y - Hwcospt9prm_s1y*expMUexpnu
Hwcospt6prm_s1y = Hwcospt7*sqrtdeltaRprm_s1y + Hwcospt7prm_s1y*sqrtdeltaR
Hwcospt5prm_s1y = -expMUsqsqrtQplusQ*xi2prm_s1y - expMUsqsqrtQplusQprm_s1y*xi2 + pvrsqprm_s1y
Hwcospt4prm_s1y = Hwcospt6*pnprm_s1y + Hwcospt6prm_s1y*pn
Hwcospt3prm_s1y = Hwcospt5*deltaTprm_s1y + Hwcospt5prm_s1y*deltaT - expMUsqexpnusq*pxirsqprm_s1y - expMUsqexpnusqprm_s1y*pxirsq
Hwcospt2prm_s1y = -B*Hwcospt4prm_s1y - Bprm_s1y*Hwcospt4 + Hwcospt3*snprm_s1y + Hwcospt3prm_s1y*sn
Hwcospt1prm_s1y = Hwcospt2*invexpMUcubinvexpnuprm_s1y + Hwcospt2prm_s1y*invexpMUcubinvexpnu
Hwcosprm_s1y = Hwcospt1*invtwoB1psqrtQsqrtQprm_s1y + Hwcospt1prm_s1y*invtwoB1psqrtQsqrtQ
deltaTsqrtQprm_s1y = deltaT*sqrtQprm_s1y + deltaTprm_s1y*sqrtQ
invdeltatTsqrtQprm_s1y = -deltaTsqrtQprm_s1y/deltaTsqrtQ**2
HSOLpt5prm_s1y = pxir*(-Bprm_s1y + expMUexpnuprm_s1y) + pxirprm_s1y*(-B + expMUexpnu)
HSOLpt4prm_s1y = HSOLpt5*invexpMUprm_s1y + HSOLpt5prm_s1y*invexpMU
HSOLpt3prm_s1y = HSOLpt4*expnusqprm_s1y + HSOLpt4prm_s1y*expnusq
HSOLpt2prm_s1y = HSOLpt3*s3prm_s1y + HSOLpt3prm_s1y*s3
HSOLpt1prm_s1y = HSOLpt2*invxi2prm_s1y + HSOLpt2prm_s1y*invxi2
HSOLprm_s1y = HSOLpt1*invdeltatTsqrtQprm_s1y + HSOLpt1prm_s1y*invdeltatTsqrtQ
deltaTsqrtQplusQprm_s1y = deltaT*(Qprm_s1y + sqrtQprm_s1y) + deltaTprm_s1y*(Q + sqrtQ)
invdeltaTsqrtQplusQprm_s1y = -deltaTsqrtQplusQprm_s1y/deltaTsqrtQplusQ**2
HSONLmult2prm_s1y = invdeltaTsqrtQplusQ*invxi2prm_s1y + invdeltaTsqrtQplusQprm_s1y*invxi2
HSONLmultprm_s1y = HSONLmult2*expnuinvexpMU2prm_s1y + HSONLmult2prm_s1y*expnuinvexpMU2
HSONLpt1bprm_s1y = pn*xi2prm_s1y + pnprm_s1y*xi2
HSONLpt1aprm_s1y = HSONLpt1b*(-mucosprm_s1y + nucosprm_s1y) + HSONLpt1bprm_s1y*(-mucos + nucos) + mur*pvrprm_s1y + murprm_s1y*pvr - nur*pvrprm_s1y - nurprm_s1y*pvr
HSONLpt1prm_s1y = HSONLpt1a*sqrtQprm_s1y + HSONLpt1aprm_s1y*sqrtQ - HSONLpt1b*mucosprm_s1y - HSONLpt1bprm_s1y*mucos + mur*pvrprm_s1y + murprm_s1y*pvr
HSONLpt2dprm_s1y = nur*pxirprm_s1y + nurprm_s1y*pxir
HSONLpt2cprm_s1y = HSONLpt2d*oneplus2sqrtQprm_s1y + HSONLpt2dprm_s1y*oneplus2sqrtQ
HSONLpt2bprm_s1y = B*sxiprm_s1y + Bprm_s1y*sxi
HSONLpt2aprm_s1y = HSONLpt2c*expMUexpnuprm_s1y + HSONLpt2cprm_s1y*expMUexpnu
HSONLpt2prm_s1y = HSONLpt1*HSONLpt2bprm_s1y + HSONLpt1prm_s1y*HSONLpt2b + HSONLpt2a*svprm_s1y + HSONLpt2aprm_s1y*sv
HSONLpt3cprm_s1y = pxir*svprm_s1y + pxirprm_s1y*sv
HSONLpt3bprm_s1y = HSONLpt3c*oneplus1sqrtQprm_s1y + HSONLpt3cprm_s1y*oneplus1sqrtQ
HSONLpt3aprm_s1y = HSONLpt3b*expMUexpnuprm_s1y + HSONLpt3bprm_s1y*expMUexpnu
HSONLpt3prm_s1y = B*HSONLpt2prm_s1y - BR*HSONLpt3aprm_s1y - BRprm_s1y*HSONLpt3a + Bprm_s1y*HSONLpt2
HSONLpt4eprm_s1y = sn*xi2prm_s1y + snprm_s1y*xi2
HSONLpt4dprm_s1y = HSONLpt4e*oneplus2sqrtQprm_s1y + HSONLpt4eprm_s1y*oneplus2sqrtQ
HSONLpt4cprm_s1y = HSONLpt4d*pxirprm_s1y + HSONLpt4dprm_s1y*pxir
HSONLpt4bprm_s1y = HSONLpt4c*nucosprm_s1y + HSONLpt4cprm_s1y*nucos
HSONLpt4aprm_s1y = HSONLpt4b*expMUexpnuprm_s1y + HSONLpt4bprm_s1y*expMUexpnu
HSONLpt4prm_s1y = -B*HSONLpt4aprm_s1y - Bprm_s1y*HSONLpt4a + HSONLpt3*sqrtdeltaRprm_s1y + HSONLpt3prm_s1y*sqrtdeltaR
HSONLprm_s1y = HSONLmult*HSONLpt4prm_s1y + HSONLmultprm_s1y*HSONLpt4
Hsprm_s1y = HSOLprm_s1y + HSONLprm_s1y + Hwcos*wcosprm_s1y + Hwcosprm_s1y*wcos + Hwr*wrprm_s1y + Hwrprm_s1y*wr + s3*wprm_s1y + s3prm_s1y*w
Hsspt1prm_s1y = 3*sn*snprm_s1y - sx*sxprm_s1y - sy*syprm_s1y - sz*szprm_s1y
Hssprm_s1y = Hsspt1prm_s1y*u3
sKerrdotsStarprm_s1y = sKerrUSCOREy*sStarUSCOREyprm_s1y + sKerrUSCOREyprm_s1y*sStarUSCOREy
Hpt1prm_s1y = etau4*s1dots1prm_s1y
Hprm_s1y = Hnsprm_s1y + Hpt1prm_s1y*dheffSSv2 + Hsprm_s1y + Hssprm_s1y
Hrealprm_s1y = Hprm_s1y*eta*sp.sign(H)/sp.sqrt(2*eta*(sp.Abs(H) - 1) + 1)
sigmaKerr2prm_s1z = 1
sigmaStar2prm_s1z = m2overm1
s1dots1prm_s1z = 2*s1z
sKerrUSCOREzprm_s1z = sigmaKerr2prm_s1z
sStarUSCOREzprm_s1z = sigmaStar2prm_s1z
a2prm_s1z = 2*sKerrUSCOREz*sKerrUSCOREzprm_s1z
a4prm_s1z = 2*a2*a2prm_s1z
aprm_s1z = a2prm_s1z/(2*sp.sqrt(a2))
invaprm_s1z = -aprm_s1z/a**2
k2prm_s1z = -a2prm_s1z*k0*m1PlusetaKKsq
k2sqprm_s1z = 2*k2*k2prm_s1z
k3prm_s1z = -a2prm_s1z*k1*m1PlusetaKKsq + k1*k2prm_s1z - 2.0*k2prm_s1z*m1PlusetaKK
k4prm_s1z = -1.0*a2*k2prm_s1z*m1PlusetaKKsq + a2prm_s1z*m1PlusetaKKsq*(0.5*k1sq - 1.0*k2) + 0.0833333333333333*k1*(24*k2prm_s1z*m1PlusetaKK + 12*k3prm_s1z) - 1.0*k1sq*k2prm_s1z + 1.0*k2*k2prm_s1z - 2.0*k3prm_s1z*m1PlusetaKK
k5prm_s1z = m1PlusetaKKsq*(a2*(1.0*k1*k2prm_s1z - 1.0*k3prm_s1z) + a2prm_s1z*(1.0*k1*k2 - 0.333333333333333*k1cu - 1.0*k3) - (1.0*k1*k2sqprm_s1z - 1.0*k1*k4prm_s1z - 1.0*k1cu*k2prm_s1z + 1.0*k1sq*k3prm_s1z - 1.0*k2*k3prm_s1z - 1.0*k2prm_s1z*k3)/m1PlusetaKKsq + (4.0*k1*k3prm_s1z - 4.0*k1sq*k2prm_s1z + 2.0*k2sqprm_s1z - 4.0*k4prm_s1z)/(2*m1PlusetaKK))
e3USCORExprm_s1z = invaprm_s1z*sKerrUSCOREx
e3USCOREyprm_s1z = invaprm_s1z*sKerrUSCOREy
e3USCOREzprm_s1z = inva*sKerrUSCOREzprm_s1z + invaprm_s1z*sKerrUSCOREz
costhetaprm_s1z = e3USCORExprm_s1z*nx + e3USCOREyprm_s1z*ny + e3USCOREzprm_s1z*nz
xi2prm_s1z = -2*costheta*costhetaprm_s1z
xiUSCORExprm_s1z = e3USCOREyprm_s1z*nz - e3USCOREzprm_s1z*ny
xiUSCOREyprm_s1z = -e3USCORExprm_s1z*nz + e3USCOREzprm_s1z*nx
xiUSCOREzprm_s1z = e3USCORExprm_s1z*ny - e3USCOREyprm_s1z*nx
vxprm_s1z = ny*xiUSCOREzprm_s1z - nz*xiUSCOREyprm_s1z
vyprm_s1z = -nx*xiUSCOREzprm_s1z + nz*xiUSCORExprm_s1z
vzprm_s1z = nx*xiUSCOREyprm_s1z - ny*xiUSCORExprm_s1z
w2prm_s1z = a2prm_s1z
rho2prm_s1z = 2*a2*costheta*costhetaprm_s1z + a2prm_s1z*costheta**2
bulkprm_s1z = a2prm_s1z*u2
logargprm_s1z = k2prm_s1z*u2 + k3prm_s1z*u3 + k4prm_s1z*u4 + k5prm_s1z*u5
onepluslogargprm_s1z = logargprm_s1z
invonepluslogargprm_s1z = -onepluslogargprm_s1z/onepluslogarg**2
logTermsprm_s1z = eta*onepluslogargprm_s1z*sp.sign(onepluslogarg)/sp.Abs(onepluslogarg)
deltaUprm_s1z = (bulk*logTermsprm_s1z + bulkprm_s1z*logTerms)*sp.sign(bulk*logTerms)
deltaTprm_s1z = deltaUprm_s1z*r2
deltaUUSCOREupt7prm_s1z = k5prm_s1z
deltaUUSCOREupt6prm_s1z = 5*deltaUUSCOREupt7prm_s1z*u + 4*k4prm_s1z
deltaUUSCOREupt5prm_s1z = deltaUUSCOREupt6prm_s1z*u + 3*k3prm_s1z
deltaUUSCOREupt4prm_s1z = deltaUUSCOREupt5prm_s1z*u + 2*k2prm_s1z
deltaUUSCOREupt3prm_s1z = deltaUUSCOREupt4prm_s1z*u
deltaUUSCOREupt2prm_s1z = a2prm_s1z*u
deltaUUSCOREupt1prm_s1z = bulk*deltaUUSCOREupt3prm_s1z*eta + bulkprm_s1z*deltaUUSCOREupt3*eta
deltaUUSCOREuprm_s1z = deltaUUSCOREupt1*invonepluslogargprm_s1z + deltaUUSCOREupt1prm_s1z*invonepluslogarg + 2*deltaUUSCOREupt2*logTermsprm_s1z + 2*deltaUUSCOREupt2prm_s1z*logTerms
deltaTUSCORErprm_s1z = -deltaUUSCOREuprm_s1z + 2*deltaUprm_s1z*r
Lambprm_s1z = (a2*deltaT*xi2prm_s1z + a2*deltaTprm_s1z*xi2 + a2prm_s1z*deltaT*xi2 - 2*w2*w2prm_s1z)*sp.sign(a2*deltaT*xi2 - w2**2)
rho2xi2Lambprm_s1z = Lamb*rho2*xi2prm_s1z + Lamb*rho2prm_s1z*xi2 + Lambprm_s1z*rho2*xi2
invrho2xi2Lambprm_s1z = -rho2xi2Lambprm_s1z/rho2xi2Lamb**2
invrho2prm_s1z = -rho2prm_s1z/rho2**2
invxi2prm_s1z = -xi2prm_s1z/xi2**2
invLambprm_s1z = -Lambprm_s1z/Lamb**2
invLambsqprm_s1z = 2*invLamb*invLambprm_s1z
rho2invLambprm_s1z = invLamb*rho2prm_s1z + invLambprm_s1z*rho2
expnuprm_s1z = sp.sqrt(deltaT*rho2invLamb)*(deltaT*rho2invLambprm_s1z/2 + deltaTprm_s1z*rho2invLamb/2)/(deltaT*rho2invLamb)
expMUprm_s1z = rho2prm_s1z/(2*sp.sqrt(rho2))
expMUexpnuprm_s1z = expMU*expnuprm_s1z + expMUprm_s1z*expnu
expMUsqprm_s1z = 2*expMU*expMUprm_s1z
expnusqprm_s1z = 2*expnu*expnuprm_s1z
expMUsqexpnusqprm_s1z = expMUsq*expnusqprm_s1z + expMUsqprm_s1z*expnusq
invexpnuexpMUprm_s1z = -expMUexpnuprm_s1z/expMUexpnu**2
invexpMUprm_s1z = expnu*invexpnuexpMUprm_s1z + expnuprm_s1z*invexpnuexpMU
invexpMUsqprm_s1z = 2*invexpMU*invexpMUprm_s1z
expnuinvexpMU2prm_s1z = expnu*invexpMUsqprm_s1z + expnuprm_s1z*invexpMUsq
invexpMUcubinvexpnuprm_s1z = invexpMUsq*invexpnuexpMUprm_s1z + invexpMUsqprm_s1z*invexpnuexpMU
deltaRprm_s1z = DD*deltaTprm_s1z
wwprm_s1z = a*a2prm_s1z*b3*eta*u + a2*aprm_s1z*b3*eta*u + aprm_s1z*bb3*eta*u + 2*aprm_s1z*r
Bprm_s1z = deltaTprm_s1z/(2*sp.sqrt(deltaT))
sqrtdeltaTprm_s1z = Bprm_s1z
sqrtdeltaRprm_s1z = deltaRprm_s1z/(2*sp.sqrt(deltaR))
deltaTsqrtdeltaRprm_s1z = deltaT*sqrtdeltaRprm_s1z + deltaTprm_s1z*sqrtdeltaR
sqrtdeltaTdeltaTsqrtdeltaRprm_s1z = deltaTsqrtdeltaR*sqrtdeltaTprm_s1z + deltaTsqrtdeltaRprm_s1z*sqrtdeltaT
invdeltaTsqrtdeltaTsqrtdeltaRprm_s1z = -1.0*sqrtdeltaTdeltaTsqrtdeltaRprm_s1z/sqrtdeltaTdeltaTsqrtdeltaR**2
invdeltaTprm_s1z = invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaR*sqrtdeltaTprm_s1z + invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaRprm_s1z*sqrtdeltaT + invdeltaTsqrtdeltaTsqrtdeltaRprm_s1z*sqrtdeltaR*sqrtdeltaT
invsqrtdeltaTprm_s1z = deltaTsqrtdeltaR*invdeltaTsqrtdeltaTsqrtdeltaRprm_s1z + deltaTsqrtdeltaRprm_s1z*invdeltaTsqrtdeltaTsqrtdeltaR
invsqrtdeltaRprm_s1z = deltaT*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaTprm_s1z + deltaT*invdeltaTsqrtdeltaTsqrtdeltaRprm_s1z*sqrtdeltaT + deltaTprm_s1z*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaT
wprm_s1z = invLamb*wwprm_s1z + invLambprm_s1z*ww
LambUSCORErprm_s1z = -a2*deltaTUSCOREr*xi2prm_s1z - a2*deltaTUSCORErprm_s1z*xi2 - a2prm_s1z*deltaTUSCOREr*xi2 + 4*r*w2prm_s1z
wwUSCORErprm_s1z = -a*a2prm_s1z*b3*eta*u2 - a2*aprm_s1z*b3*eta*u2 - aprm_s1z*bb3*eta*u2 + 2*aprm_s1z
BRprm_s1z = invsqrtdeltaT*(-deltaT*invsqrtdeltaRprm_s1z + deltaTUSCORErprm_s1z/2 - deltaTprm_s1z*invsqrtdeltaR) + invsqrtdeltaTprm_s1z*(-deltaT*invsqrtdeltaR + deltaTUSCOREr/2)
wrprm_s1z = invLambsq*(Lamb*wwUSCORErprm_s1z - LambUSCOREr*wwprm_s1z - LambUSCORErprm_s1z*ww + Lambprm_s1z*wwUSCOREr) + invLambsqprm_s1z*(Lamb*wwUSCOREr - LambUSCOREr*ww)
nurpt2prm_s1z = w2*(deltaTUSCOREr*w2prm_s1z + deltaTUSCORErprm_s1z*w2 - 4.0*deltaTprm_s1z*r) + w2prm_s1z*(-4.0*deltaT*r + deltaTUSCOREr*w2)
nurpt1prm_s1z = invdeltaT*nurpt2prm_s1z + invdeltaTprm_s1z*nurpt2
nurprm_s1z = invLamb*nurpt1prm_s1z/2 + invLambprm_s1z*nurpt1/2 + invrho2prm_s1z*r
murprm_s1z = invrho2prm_s1z*r - invsqrtdeltaRprm_s1z
a2costhetaprm_s1z = a2*costhetaprm_s1z + a2prm_s1z*costheta
wcospt2prm_s1z = deltaT*wwprm_s1z + deltaTprm_s1z*ww
wcospt1prm_s1z = invLambsq*wcospt2prm_s1z + invLambsqprm_s1z*wcospt2
wcosprm_s1z = -2*a2costheta*wcospt1prm_s1z - 2*a2costhetaprm_s1z*wcospt1
nucospt3prm_s1z = invLamb*invrho2prm_s1z + invLambprm_s1z*invrho2
nucospt2prm_s1z = nucospt3*w2prm_s1z + nucospt3prm_s1z*w2
nucospt1prm_s1z = a2costheta*nucospt2prm_s1z + a2costhetaprm_s1z*nucospt2
nucosprm_s1z = nucospt1*(-deltaTprm_s1z + w2prm_s1z) + nucospt1prm_s1z*(-deltaT + w2)
mucosprm_s1z = a2costheta*invrho2prm_s1z + a2costhetaprm_s1z*invrho2
csiprm_s1z = (deltaR*deltaTprm_s1z + deltaRprm_s1z*deltaT)*sp.sign(deltaR*deltaT)/(2*w2*sp.sqrt(sp.Abs(deltaR*deltaT))) - w2prm_s1z*sp.sqrt(sp.Abs(deltaR*deltaT))/w2**2
csi1prm_s1z = csiprm_s1z*(1 - sp.Abs(tortoise - 1))
csi2prm_s1z = csiprm_s1z*(1/2 - 0.5*sp.sign(1.5 - tortoise))
prTprm_s1z = csi2prm_s1z*(nx*px + ny*py + nz*pz)
prTtimesoneminuscsi1invprm_s1z = prTprm_s1z*(1 - 1/csi1) + csi1prm_s1z*prT/csi1**2
tmppxprm_s1z = -nx*prTtimesoneminuscsi1invprm_s1z
tmppyprm_s1z = -ny*prTtimesoneminuscsi1invprm_s1z
tmppzprm_s1z = -nz*prTtimesoneminuscsi1invprm_s1z
pxirprm_s1z = r*(tmppx*xiUSCORExprm_s1z + tmppxprm_s1z*xiUSCOREx + tmppy*xiUSCOREyprm_s1z + tmppyprm_s1z*xiUSCOREy + tmppz*xiUSCOREzprm_s1z + tmppzprm_s1z*xiUSCOREz)
pvrprm_s1z = r*(tmppx*vxprm_s1z + tmppxprm_s1z*vx + tmppy*vyprm_s1z + tmppyprm_s1z*vy + tmppz*vzprm_s1z + tmppzprm_s1z*vz)
pvrsqprm_s1z = 2*pvr*pvrprm_s1z
pnprm_s1z = nx*tmppxprm_s1z + ny*tmppyprm_s1z + nz*tmppzprm_s1z
pnsqprm_s1z = 2*pn*pnprm_s1z
prprm_s1z = pnprm_s1z
prsqprm_s1z = 2*pr*prprm_s1z
pfprm_s1z = pxirprm_s1z
pxirsqprm_s1z = 2*pxir*pxirprm_s1z
ptheta2prm_s1z = invxi2*pvrsqprm_s1z + invxi2prm_s1z*pvrsq
prT4prm_s1z = 4*prT**3*prTprm_s1z
Hnspt7prm_s1z = deltaR*invrho2prm_s1z + deltaRprm_s1z*invrho2
Hnspt6prm_s1z = invxi2*rho2invLambprm_s1z + invxi2prm_s1z*rho2invLamb
Hnspt4prm_s1z = Hnspt5*prT4prm_s1z + 2*Hnspt6*pf*pfprm_s1z + Hnspt6prm_s1z*pf**2 + Hnspt7*prsqprm_s1z + Hnspt7prm_s1z*prsq + invrho2*ptheta2prm_s1z + invrho2prm_s1z*ptheta2
Hnspt3prm_s1z = Hnspt4*deltaTprm_s1z + Hnspt4prm_s1z*deltaT
Hnspt2prm_s1z = Hnspt3*rho2prm_s1z + Hnspt3prm_s1z*rho2
Hnspt1prm_s1z = pf*wwprm_s1z + pfprm_s1z*ww
Hnsprm_s1z = Hnspt1*invLambprm_s1z + Hnspt1prm_s1z*invLamb + sp.sqrt(Hnspt2*invLamb)*(Hnspt2*invLambprm_s1z/2 + Hnspt2prm_s1z*invLamb/2)/(Hnspt2*invLamb)
Qpt3prm_s1z = deltaR*invrho2prm_s1z + deltaRprm_s1z*invrho2
Qpt2prm_s1z = invxi2*rho2invLambprm_s1z + invxi2prm_s1z*rho2invLamb
Qpt1prm_s1z = invrho2*invxi2prm_s1z + invrho2prm_s1z*invxi2
Qprm_s1z = Qpt1*pvrsqprm_s1z + Qpt1prm_s1z*pvrsq + Qpt2*pxirsqprm_s1z + Qpt2prm_s1z*pxirsq + Qpt3*pnsqprm_s1z + Qpt3prm_s1z*pnsq
pn2prm_s1z = deltaR*invrho2*prsqprm_s1z + deltaR*invrho2prm_s1z*prsq + deltaRprm_s1z*invrho2*prsq
ppprm_s1z = Qprm_s1z
sKerrmultfactprm_s1z = r*(-36*pn2prm_s1z + 3*ppprm_s1z)
sStarmultfactprm_s1z = r*(-30*pn2prm_s1z + 4*ppprm_s1z)
deltaSigmaStarUSCOREx1prm_s1z = etaover12r*(sKerrUSCOREx*sKerrmultfactprm_s1z + sStarUSCOREx*sStarmultfactprm_s1z)
deltaSigmaStarUSCOREy1prm_s1z = etaover12r*(sKerrUSCOREy*sKerrmultfactprm_s1z + sStarUSCOREy*sStarmultfactprm_s1z)
deltaSigmaStarUSCOREz1prm_s1z = etaover12r*(sKerrUSCOREz*sKerrmultfactprm_s1z + sKerrUSCOREzprm_s1z*sKerrmultfact + sStarUSCOREz*sStarmultfactprm_s1z + sStarUSCOREzprm_s1z*sStarmultfact)
pn2ppprm_s1z = pn2*ppprm_s1z + pn2prm_s1z*pp
pp2prm_s1z = 2*pp*ppprm_s1z
pn2u2prm_s1z = pn2prm_s1z*u2
ppu2prm_s1z = ppprm_s1z*u2
pn2ppu2prm_s1z = pn2ppprm_s1z*u2
sMultiplier1pt6prm_s1z = -720*pn2*pn2prm_s1z + 126*pn2ppprm_s1z + 3*pp2prm_s1z
sMultiplier1pt5prm_s1z = -96*pn2ppprm_s1z + 23*pp2prm_s1z
sMultiplier1pt4prm_s1z = 324*pn2prm_s1z - 120*ppprm_s1z + r*sMultiplier1pt6prm_s1z
sMultiplier1pt3prm_s1z = -282*pn2prm_s1z + 206*ppprm_s1z + r*sMultiplier1pt5prm_s1z
sMultiplier1pt2prm_s1z = r*sMultiplier1pt4prm_s1z
sMultiplier1pt1prm_s1z = eta*sMultiplier1pt2prm_s1z + r*sMultiplier1pt3prm_s1z
sMultiplier1prm_s1z = -eta*sMultiplier1pt1prm_s1z*u2/72
sMultiplier2pt6prm_s1z = 45*pn2*pn2u2prm_s1z/8 - 13*pn2ppu2prm_s1z/8 + 45*pn2prm_s1z*pn2u2/8
sMultiplier2pt5prm_s1z = pn2ppu2prm_s1z/4 - 5*pp2prm_s1z*u2/16
sMultiplier2pt4prm_s1z = -49*pn2u2prm_s1z/8 + 17*ppu2prm_s1z/12 + r*sMultiplier2pt6prm_s1z
sMultiplier2pt3prm_s1z = -2*pn2u2prm_s1z/3 - 109*ppu2prm_s1z/36 + r*sMultiplier2pt5prm_s1z
sMultiplier2pt2prm_s1z = r*sMultiplier2pt4prm_s1z
sMultiplier2pt1prm_s1z = eta*sMultiplier2pt2prm_s1z + r*sMultiplier2pt3prm_s1z
sMultiplier2prm_s1z = eta*sMultiplier2pt1prm_s1z
deltaSigmaStarUSCOREx2prm_s1z = deltaSigmaStarUSCOREx1prm_s1z + sMultiplier1prm_s1z*sigmaStar0 + sMultiplier2prm_s1z*sigmaKerr0
deltaSigmaStarUSCOREy2prm_s1z = deltaSigmaStarUSCOREy1prm_s1z + sMultiplier1prm_s1z*sigmaStar1 + sMultiplier2prm_s1z*sigmaKerr1
deltaSigmaStarUSCOREz2prm_s1z = deltaSigmaStarUSCOREz1prm_s1z + sMultiplier1*sigmaStar2prm_s1z + sMultiplier1prm_s1z*sigmaStar2 + sMultiplier2*sigmaKerr2prm_s1z + sMultiplier2prm_s1z*sigmaKerr2
deltaSigmaStarUSCORExprm_s1z = deltaSigmaStarUSCOREx2prm_s1z
deltaSigmaStarUSCOREyprm_s1z = deltaSigmaStarUSCOREy2prm_s1z
deltaSigmaStarUSCOREzprm_s1z = d1v2*etau3*sigmaKerr2prm_s1z + deltaSigmaStarUSCOREz2prm_s1z
sxprm_s1z = deltaSigmaStarUSCORExprm_s1z
syprm_s1z = deltaSigmaStarUSCOREyprm_s1z
szprm_s1z = deltaSigmaStarUSCOREzprm_s1z + sStarUSCOREzprm_s1z
sxiprm_s1z = sx*xiUSCORExprm_s1z + sxprm_s1z*xiUSCOREx + sy*xiUSCOREyprm_s1z + syprm_s1z*xiUSCOREy + sz*xiUSCOREzprm_s1z + szprm_s1z*xiUSCOREz
svprm_s1z = sx*vxprm_s1z + sxprm_s1z*vx + sy*vyprm_s1z + syprm_s1z*vy + sz*vzprm_s1z + szprm_s1z*vz
snprm_s1z = nx*sxprm_s1z + ny*syprm_s1z + nz*szprm_s1z
s3prm_s1z = e3USCOREx*sxprm_s1z + e3USCORExprm_s1z*sx + e3USCOREy*syprm_s1z + e3USCOREyprm_s1z*sy + e3USCOREz*szprm_s1z + e3USCOREzprm_s1z*sz
sqrtQprm_s1z = Qprm_s1z/(2*sp.sqrt(Q))
oneplus2sqrtQprm_s1z = 2*sqrtQprm_s1z
oneplus1sqrtQprm_s1z = oneplus2sqrtQprm_s1z - sqrtQprm_s1z
twoB1psqrtQsqrtQprm_s1z = 2*B*oneplus1sqrtQ*sqrtQprm_s1z + 2*B*oneplus1sqrtQprm_s1z*sqrtQ + 2*Bprm_s1z*oneplus1sqrtQ*sqrtQ
invtwoB1psqrtQsqrtQprm_s1z = -twoB1psqrtQsqrtQprm_s1z/twoB1psqrtQsqrtQ**2
expMUsqsqrtQplusQprm_s1z = expMUsq*(Qprm_s1z + sqrtQprm_s1z) + expMUsqprm_s1z*(Q + sqrtQ)
Hwrpt4aprm_s1z = pxirsq*svprm_s1z + pxirsqprm_s1z*sv
Hwrpt4prm_s1z = Hwrpt4a*expMUsqexpnusqprm_s1z + Hwrpt4aprm_s1z*expMUsqexpnusq
Hwrpt3cprm_s1z = pxir*sxiprm_s1z + pxirprm_s1z*sxi
Hwrpt3bprm_s1z = Hwrpt3c*pvrprm_s1z + Hwrpt3cprm_s1z*pvr
Hwrpt3aprm_s1z = Hwrpt3b*expMUexpnuprm_s1z + Hwrpt3bprm_s1z*expMUexpnu
Hwrpt3prm_s1z = B*Hwrpt3aprm_s1z + Bprm_s1z*Hwrpt3a
Hwrpt2gprm_s1z = deltaR*svprm_s1z + deltaRprm_s1z*sv
Hwrpt2fprm_s1z = sn*sqrtdeltaRprm_s1z + snprm_s1z*sqrtdeltaR
Hwrpt2eprm_s1z = Hwrpt2f*pvrprm_s1z + Hwrpt2fprm_s1z*pvr
Hwrpt2dprm_s1z = Hwrpt2g*pnsqprm_s1z + Hwrpt2gprm_s1z*pnsq
Hwrpt2cprm_s1z = Hwrpt2e*pnprm_s1z + Hwrpt2eprm_s1z*pn
Hwrpt2bprm_s1z = expMUsqsqrtQplusQ*svprm_s1z + expMUsqsqrtQplusQprm_s1z*sv
Hwrpt2aprm_s1z = xi2*(Hwrpt2bprm_s1z + Hwrpt2cprm_s1z - Hwrpt2dprm_s1z) + xi2prm_s1z*(Hwrpt2b + Hwrpt2c - Hwrpt2d)
Hwrpt2prm_s1z = Hwrpt2a*deltaTprm_s1z + Hwrpt2aprm_s1z*deltaT
Hwrpt1bprm_s1z = invtwoB1psqrtQsqrtQ*invxi2prm_s1z + invtwoB1psqrtQsqrtQprm_s1z*invxi2
Hwrpt1aprm_s1z = Hwrpt1b*sqrtdeltaRprm_s1z + Hwrpt1bprm_s1z*sqrtdeltaR
Hwrpt1prm_s1z = Hwrpt1a*invexpMUcubinvexpnuprm_s1z + Hwrpt1aprm_s1z*invexpMUcubinvexpnu
Hwrprm_s1z = Hwrpt1*(Hwrpt2prm_s1z - Hwrpt3prm_s1z + Hwrpt4prm_s1z) + Hwrpt1prm_s1z*(Hwrpt2 - Hwrpt3 + Hwrpt4)
Hwcospt9prm_s1z = pxir*sxiprm_s1z + pxirprm_s1z*sxi
Hwcospt8prm_s1z = pvr*svprm_s1z + pvrprm_s1z*sv
Hwcospt7prm_s1z = B*Hwcospt8prm_s1z + Bprm_s1z*Hwcospt8 - Hwcospt9*expMUexpnuprm_s1z - Hwcospt9prm_s1z*expMUexpnu
Hwcospt6prm_s1z = Hwcospt7*sqrtdeltaRprm_s1z + Hwcospt7prm_s1z*sqrtdeltaR
Hwcospt5prm_s1z = -expMUsqsqrtQplusQ*xi2prm_s1z - expMUsqsqrtQplusQprm_s1z*xi2 + pvrsqprm_s1z
Hwcospt4prm_s1z = Hwcospt6*pnprm_s1z + Hwcospt6prm_s1z*pn
Hwcospt3prm_s1z = Hwcospt5*deltaTprm_s1z + Hwcospt5prm_s1z*deltaT - expMUsqexpnusq*pxirsqprm_s1z - expMUsqexpnusqprm_s1z*pxirsq
Hwcospt2prm_s1z = -B*Hwcospt4prm_s1z - Bprm_s1z*Hwcospt4 + Hwcospt3*snprm_s1z + Hwcospt3prm_s1z*sn
Hwcospt1prm_s1z = Hwcospt2*invexpMUcubinvexpnuprm_s1z + Hwcospt2prm_s1z*invexpMUcubinvexpnu
Hwcosprm_s1z = Hwcospt1*invtwoB1psqrtQsqrtQprm_s1z + Hwcospt1prm_s1z*invtwoB1psqrtQsqrtQ
deltaTsqrtQprm_s1z = deltaT*sqrtQprm_s1z + deltaTprm_s1z*sqrtQ
invdeltatTsqrtQprm_s1z = -deltaTsqrtQprm_s1z/deltaTsqrtQ**2
HSOLpt5prm_s1z = pxir*(-Bprm_s1z + expMUexpnuprm_s1z) + pxirprm_s1z*(-B + expMUexpnu)
HSOLpt4prm_s1z = HSOLpt5*invexpMUprm_s1z + HSOLpt5prm_s1z*invexpMU
HSOLpt3prm_s1z = HSOLpt4*expnusqprm_s1z + HSOLpt4prm_s1z*expnusq
HSOLpt2prm_s1z = HSOLpt3*s3prm_s1z + HSOLpt3prm_s1z*s3
HSOLpt1prm_s1z = HSOLpt2*invxi2prm_s1z + HSOLpt2prm_s1z*invxi2
HSOLprm_s1z = HSOLpt1*invdeltatTsqrtQprm_s1z + HSOLpt1prm_s1z*invdeltatTsqrtQ
deltaTsqrtQplusQprm_s1z = deltaT*(Qprm_s1z + sqrtQprm_s1z) + deltaTprm_s1z*(Q + sqrtQ)
invdeltaTsqrtQplusQprm_s1z = -deltaTsqrtQplusQprm_s1z/deltaTsqrtQplusQ**2
HSONLmult2prm_s1z = invdeltaTsqrtQplusQ*invxi2prm_s1z + invdeltaTsqrtQplusQprm_s1z*invxi2
HSONLmultprm_s1z = HSONLmult2*expnuinvexpMU2prm_s1z + HSONLmult2prm_s1z*expnuinvexpMU2
HSONLpt1bprm_s1z = pn*xi2prm_s1z + pnprm_s1z*xi2
HSONLpt1aprm_s1z = HSONLpt1b*(-mucosprm_s1z + nucosprm_s1z) + HSONLpt1bprm_s1z*(-mucos + nucos) + mur*pvrprm_s1z + murprm_s1z*pvr - nur*pvrprm_s1z - nurprm_s1z*pvr
HSONLpt1prm_s1z = HSONLpt1a*sqrtQprm_s1z + HSONLpt1aprm_s1z*sqrtQ - HSONLpt1b*mucosprm_s1z - HSONLpt1bprm_s1z*mucos + mur*pvrprm_s1z + murprm_s1z*pvr
HSONLpt2dprm_s1z = nur*pxirprm_s1z + nurprm_s1z*pxir
HSONLpt2cprm_s1z = HSONLpt2d*oneplus2sqrtQprm_s1z + HSONLpt2dprm_s1z*oneplus2sqrtQ
HSONLpt2bprm_s1z = B*sxiprm_s1z + Bprm_s1z*sxi
HSONLpt2aprm_s1z = HSONLpt2c*expMUexpnuprm_s1z + HSONLpt2cprm_s1z*expMUexpnu
HSONLpt2prm_s1z = HSONLpt1*HSONLpt2bprm_s1z + HSONLpt1prm_s1z*HSONLpt2b + HSONLpt2a*svprm_s1z + HSONLpt2aprm_s1z*sv
HSONLpt3cprm_s1z = pxir*svprm_s1z + pxirprm_s1z*sv
HSONLpt3bprm_s1z = HSONLpt3c*oneplus1sqrtQprm_s1z + HSONLpt3cprm_s1z*oneplus1sqrtQ
HSONLpt3aprm_s1z = HSONLpt3b*expMUexpnuprm_s1z + HSONLpt3bprm_s1z*expMUexpnu
HSONLpt3prm_s1z = B*HSONLpt2prm_s1z - BR*HSONLpt3aprm_s1z - BRprm_s1z*HSONLpt3a + Bprm_s1z*HSONLpt2
HSONLpt4eprm_s1z = sn*xi2prm_s1z + snprm_s1z*xi2
HSONLpt4dprm_s1z = HSONLpt4e*oneplus2sqrtQprm_s1z + HSONLpt4eprm_s1z*oneplus2sqrtQ
HSONLpt4cprm_s1z = HSONLpt4d*pxirprm_s1z + HSONLpt4dprm_s1z*pxir
HSONLpt4bprm_s1z = HSONLpt4c*nucosprm_s1z + HSONLpt4cprm_s1z*nucos
HSONLpt4aprm_s1z = HSONLpt4b*expMUexpnuprm_s1z + HSONLpt4bprm_s1z*expMUexpnu
HSONLpt4prm_s1z = -B*HSONLpt4aprm_s1z - Bprm_s1z*HSONLpt4a + HSONLpt3*sqrtdeltaRprm_s1z + HSONLpt3prm_s1z*sqrtdeltaR
HSONLprm_s1z = HSONLmult*HSONLpt4prm_s1z + HSONLmultprm_s1z*HSONLpt4
Hsprm_s1z = HSOLprm_s1z + HSONLprm_s1z + Hwcos*wcosprm_s1z + Hwcosprm_s1z*wcos + Hwr*wrprm_s1z + Hwrprm_s1z*wr + s3*wprm_s1z + s3prm_s1z*w
Hsspt1prm_s1z = 3*sn*snprm_s1z - sx*sxprm_s1z - sy*syprm_s1z - sz*szprm_s1z
Hssprm_s1z = Hsspt1prm_s1z*u3
sKerrdotsStarprm_s1z = sKerrUSCOREz*sStarUSCOREzprm_s1z + sKerrUSCOREzprm_s1z*sStarUSCOREz
Hpt1prm_s1z = etau4*s1dots1prm_s1z
Hprm_s1z = Hnsprm_s1z + Hpt1prm_s1z*dheffSSv2 + Hsprm_s1z + Hssprm_s1z
Hrealprm_s1z = Hprm_s1z*eta*sp.sign(H)/sp.sqrt(2*eta*(sp.Abs(H) - 1) + 1)
sigmaKerr0prm_s2x = 1
sigmaStar0prm_s2x = m1overm2
s2dots2prm_s2x = 2*s2x
sKerrUSCORExprm_s2x = sigmaKerr0prm_s2x
sStarUSCORExprm_s2x = sigmaStar0prm_s2x
a2prm_s2x = 2*sKerrUSCOREx*sKerrUSCORExprm_s2x
a4prm_s2x = 2*a2*a2prm_s2x
aprm_s2x = a2prm_s2x/(2*sp.sqrt(a2))
invaprm_s2x = -aprm_s2x/a**2
k2prm_s2x = -a2prm_s2x*k0*m1PlusetaKKsq
k2sqprm_s2x = 2*k2*k2prm_s2x
k3prm_s2x = -a2prm_s2x*k1*m1PlusetaKKsq + k1*k2prm_s2x - 2.0*k2prm_s2x*m1PlusetaKK
k4prm_s2x = -1.0*a2*k2prm_s2x*m1PlusetaKKsq + a2prm_s2x*m1PlusetaKKsq*(0.5*k1sq - 1.0*k2) + 0.0833333333333333*k1*(24*k2prm_s2x*m1PlusetaKK + 12*k3prm_s2x) - 1.0*k1sq*k2prm_s2x + 1.0*k2*k2prm_s2x - 2.0*k3prm_s2x*m1PlusetaKK
k5prm_s2x = m1PlusetaKKsq*(a2*(1.0*k1*k2prm_s2x - 1.0*k3prm_s2x) + a2prm_s2x*(1.0*k1*k2 - 0.333333333333333*k1cu - 1.0*k3) - (1.0*k1*k2sqprm_s2x - 1.0*k1*k4prm_s2x - 1.0*k1cu*k2prm_s2x + 1.0*k1sq*k3prm_s2x - 1.0*k2*k3prm_s2x - 1.0*k2prm_s2x*k3)/m1PlusetaKKsq + (4.0*k1*k3prm_s2x - 4.0*k1sq*k2prm_s2x + 2.0*k2sqprm_s2x - 4.0*k4prm_s2x)/(2*m1PlusetaKK))
e3USCORExprm_s2x = inva*sKerrUSCORExprm_s2x + invaprm_s2x*sKerrUSCOREx
e3USCOREyprm_s2x = invaprm_s2x*sKerrUSCOREy
e3USCOREzprm_s2x = invaprm_s2x*sKerrUSCOREz
costhetaprm_s2x = e3USCORExprm_s2x*nx + e3USCOREyprm_s2x*ny + e3USCOREzprm_s2x*nz
xi2prm_s2x = -2*costheta*costhetaprm_s2x
xiUSCORExprm_s2x = e3USCOREyprm_s2x*nz - e3USCOREzprm_s2x*ny
xiUSCOREyprm_s2x = -e3USCORExprm_s2x*nz + e3USCOREzprm_s2x*nx
xiUSCOREzprm_s2x = e3USCORExprm_s2x*ny - e3USCOREyprm_s2x*nx
vxprm_s2x = ny*xiUSCOREzprm_s2x - nz*xiUSCOREyprm_s2x
vyprm_s2x = -nx*xiUSCOREzprm_s2x + nz*xiUSCORExprm_s2x
vzprm_s2x = nx*xiUSCOREyprm_s2x - ny*xiUSCORExprm_s2x
w2prm_s2x = a2prm_s2x
rho2prm_s2x = 2*a2*costheta*costhetaprm_s2x + a2prm_s2x*costheta**2
bulkprm_s2x = a2prm_s2x*u2
logargprm_s2x = k2prm_s2x*u2 + k3prm_s2x*u3 + k4prm_s2x*u4 + k5prm_s2x*u5
onepluslogargprm_s2x = logargprm_s2x
invonepluslogargprm_s2x = -onepluslogargprm_s2x/onepluslogarg**2
logTermsprm_s2x = eta*onepluslogargprm_s2x*sp.sign(onepluslogarg)/sp.Abs(onepluslogarg)
deltaUprm_s2x = (bulk*logTermsprm_s2x + bulkprm_s2x*logTerms)*sp.sign(bulk*logTerms)
deltaTprm_s2x = deltaUprm_s2x*r2
deltaUUSCOREupt7prm_s2x = k5prm_s2x
deltaUUSCOREupt6prm_s2x = 5*deltaUUSCOREupt7prm_s2x*u + 4*k4prm_s2x
deltaUUSCOREupt5prm_s2x = deltaUUSCOREupt6prm_s2x*u + 3*k3prm_s2x
deltaUUSCOREupt4prm_s2x = deltaUUSCOREupt5prm_s2x*u + 2*k2prm_s2x
deltaUUSCOREupt3prm_s2x = deltaUUSCOREupt4prm_s2x*u
deltaUUSCOREupt2prm_s2x = a2prm_s2x*u
deltaUUSCOREupt1prm_s2x = bulk*deltaUUSCOREupt3prm_s2x*eta + bulkprm_s2x*deltaUUSCOREupt3*eta
deltaUUSCOREuprm_s2x = deltaUUSCOREupt1*invonepluslogargprm_s2x + deltaUUSCOREupt1prm_s2x*invonepluslogarg + 2*deltaUUSCOREupt2*logTermsprm_s2x + 2*deltaUUSCOREupt2prm_s2x*logTerms
deltaTUSCORErprm_s2x = -deltaUUSCOREuprm_s2x + 2*deltaUprm_s2x*r
Lambprm_s2x = (a2*deltaT*xi2prm_s2x + a2*deltaTprm_s2x*xi2 + a2prm_s2x*deltaT*xi2 - 2*w2*w2prm_s2x)*sp.sign(a2*deltaT*xi2 - w2**2)
rho2xi2Lambprm_s2x = Lamb*rho2*xi2prm_s2x + Lamb*rho2prm_s2x*xi2 + Lambprm_s2x*rho2*xi2
invrho2xi2Lambprm_s2x = -rho2xi2Lambprm_s2x/rho2xi2Lamb**2
invrho2prm_s2x = -rho2prm_s2x/rho2**2
invxi2prm_s2x = -xi2prm_s2x/xi2**2
invLambprm_s2x = -Lambprm_s2x/Lamb**2
invLambsqprm_s2x = 2*invLamb*invLambprm_s2x
rho2invLambprm_s2x = invLamb*rho2prm_s2x + invLambprm_s2x*rho2
expnuprm_s2x = sp.sqrt(deltaT*rho2invLamb)*(deltaT*rho2invLambprm_s2x/2 + deltaTprm_s2x*rho2invLamb/2)/(deltaT*rho2invLamb)
expMUprm_s2x = rho2prm_s2x/(2*sp.sqrt(rho2))
expMUexpnuprm_s2x = expMU*expnuprm_s2x + expMUprm_s2x*expnu
expMUsqprm_s2x = 2*expMU*expMUprm_s2x
expnusqprm_s2x = 2*expnu*expnuprm_s2x
expMUsqexpnusqprm_s2x = expMUsq*expnusqprm_s2x + expMUsqprm_s2x*expnusq
invexpnuexpMUprm_s2x = -expMUexpnuprm_s2x/expMUexpnu**2
invexpMUprm_s2x = expnu*invexpnuexpMUprm_s2x + expnuprm_s2x*invexpnuexpMU
invexpMUsqprm_s2x = 2*invexpMU*invexpMUprm_s2x
expnuinvexpMU2prm_s2x = expnu*invexpMUsqprm_s2x + expnuprm_s2x*invexpMUsq
invexpMUcubinvexpnuprm_s2x = invexpMUsq*invexpnuexpMUprm_s2x + invexpMUsqprm_s2x*invexpnuexpMU
deltaRprm_s2x = DD*deltaTprm_s2x
wwprm_s2x = a*a2prm_s2x*b3*eta*u + a2*aprm_s2x*b3*eta*u + aprm_s2x*bb3*eta*u + 2*aprm_s2x*r
Bprm_s2x = deltaTprm_s2x/(2*sp.sqrt(deltaT))
sqrtdeltaTprm_s2x = Bprm_s2x
sqrtdeltaRprm_s2x = deltaRprm_s2x/(2*sp.sqrt(deltaR))
deltaTsqrtdeltaRprm_s2x = deltaT*sqrtdeltaRprm_s2x + deltaTprm_s2x*sqrtdeltaR
sqrtdeltaTdeltaTsqrtdeltaRprm_s2x = deltaTsqrtdeltaR*sqrtdeltaTprm_s2x + deltaTsqrtdeltaRprm_s2x*sqrtdeltaT
invdeltaTsqrtdeltaTsqrtdeltaRprm_s2x = -1.0*sqrtdeltaTdeltaTsqrtdeltaRprm_s2x/sqrtdeltaTdeltaTsqrtdeltaR**2
invdeltaTprm_s2x = invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaR*sqrtdeltaTprm_s2x + invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaRprm_s2x*sqrtdeltaT + invdeltaTsqrtdeltaTsqrtdeltaRprm_s2x*sqrtdeltaR*sqrtdeltaT
invsqrtdeltaTprm_s2x = deltaTsqrtdeltaR*invdeltaTsqrtdeltaTsqrtdeltaRprm_s2x + deltaTsqrtdeltaRprm_s2x*invdeltaTsqrtdeltaTsqrtdeltaR
invsqrtdeltaRprm_s2x = deltaT*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaTprm_s2x + deltaT*invdeltaTsqrtdeltaTsqrtdeltaRprm_s2x*sqrtdeltaT + deltaTprm_s2x*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaT
wprm_s2x = invLamb*wwprm_s2x + invLambprm_s2x*ww
LambUSCORErprm_s2x = -a2*deltaTUSCOREr*xi2prm_s2x - a2*deltaTUSCORErprm_s2x*xi2 - a2prm_s2x*deltaTUSCOREr*xi2 + 4*r*w2prm_s2x
wwUSCORErprm_s2x = -a*a2prm_s2x*b3*eta*u2 - a2*aprm_s2x*b3*eta*u2 - aprm_s2x*bb3*eta*u2 + 2*aprm_s2x
BRprm_s2x = invsqrtdeltaT*(-deltaT*invsqrtdeltaRprm_s2x + deltaTUSCORErprm_s2x/2 - deltaTprm_s2x*invsqrtdeltaR) + invsqrtdeltaTprm_s2x*(-deltaT*invsqrtdeltaR + deltaTUSCOREr/2)
wrprm_s2x = invLambsq*(Lamb*wwUSCORErprm_s2x - LambUSCOREr*wwprm_s2x - LambUSCORErprm_s2x*ww + Lambprm_s2x*wwUSCOREr) + invLambsqprm_s2x*(Lamb*wwUSCOREr - LambUSCOREr*ww)
nurpt2prm_s2x = w2*(deltaTUSCOREr*w2prm_s2x + deltaTUSCORErprm_s2x*w2 - 4.0*deltaTprm_s2x*r) + w2prm_s2x*(-4.0*deltaT*r + deltaTUSCOREr*w2)
nurpt1prm_s2x = invdeltaT*nurpt2prm_s2x + invdeltaTprm_s2x*nurpt2
nurprm_s2x = invLamb*nurpt1prm_s2x/2 + invLambprm_s2x*nurpt1/2 + invrho2prm_s2x*r
murprm_s2x = invrho2prm_s2x*r - invsqrtdeltaRprm_s2x
a2costhetaprm_s2x = a2*costhetaprm_s2x + a2prm_s2x*costheta
wcospt2prm_s2x = deltaT*wwprm_s2x + deltaTprm_s2x*ww
wcospt1prm_s2x = invLambsq*wcospt2prm_s2x + invLambsqprm_s2x*wcospt2
wcosprm_s2x = -2*a2costheta*wcospt1prm_s2x - 2*a2costhetaprm_s2x*wcospt1
nucospt3prm_s2x = invLamb*invrho2prm_s2x + invLambprm_s2x*invrho2
nucospt2prm_s2x = nucospt3*w2prm_s2x + nucospt3prm_s2x*w2
nucospt1prm_s2x = a2costheta*nucospt2prm_s2x + a2costhetaprm_s2x*nucospt2
nucosprm_s2x = nucospt1*(-deltaTprm_s2x + w2prm_s2x) + nucospt1prm_s2x*(-deltaT + w2)
mucosprm_s2x = a2costheta*invrho2prm_s2x + a2costhetaprm_s2x*invrho2
csiprm_s2x = (deltaR*deltaTprm_s2x + deltaRprm_s2x*deltaT)*sp.sign(deltaR*deltaT)/(2*w2*sp.sqrt(sp.Abs(deltaR*deltaT))) - w2prm_s2x*sp.sqrt(sp.Abs(deltaR*deltaT))/w2**2
csi1prm_s2x = csiprm_s2x*(1 - sp.Abs(tortoise - 1))
csi2prm_s2x = csiprm_s2x*(1/2 - 0.5*sp.sign(1.5 - tortoise))
prTprm_s2x = csi2prm_s2x*(nx*px + ny*py + nz*pz)
prTtimesoneminuscsi1invprm_s2x = prTprm_s2x*(1 - 1/csi1) + csi1prm_s2x*prT/csi1**2
tmppxprm_s2x = -nx*prTtimesoneminuscsi1invprm_s2x
tmppyprm_s2x = -ny*prTtimesoneminuscsi1invprm_s2x
tmppzprm_s2x = -nz*prTtimesoneminuscsi1invprm_s2x
pxirprm_s2x = r*(tmppx*xiUSCORExprm_s2x + tmppxprm_s2x*xiUSCOREx + tmppy*xiUSCOREyprm_s2x + tmppyprm_s2x*xiUSCOREy + tmppz*xiUSCOREzprm_s2x + tmppzprm_s2x*xiUSCOREz)
pvrprm_s2x = r*(tmppx*vxprm_s2x + tmppxprm_s2x*vx + tmppy*vyprm_s2x + tmppyprm_s2x*vy + tmppz*vzprm_s2x + tmppzprm_s2x*vz)
pvrsqprm_s2x = 2*pvr*pvrprm_s2x
pnprm_s2x = nx*tmppxprm_s2x + ny*tmppyprm_s2x + nz*tmppzprm_s2x
pnsqprm_s2x = 2*pn*pnprm_s2x
prprm_s2x = pnprm_s2x
prsqprm_s2x = 2*pr*prprm_s2x
pfprm_s2x = pxirprm_s2x
pxirsqprm_s2x = 2*pxir*pxirprm_s2x
ptheta2prm_s2x = invxi2*pvrsqprm_s2x + invxi2prm_s2x*pvrsq
prT4prm_s2x = 4*prT**3*prTprm_s2x
Hnspt7prm_s2x = deltaR*invrho2prm_s2x + deltaRprm_s2x*invrho2
Hnspt6prm_s2x = invxi2*rho2invLambprm_s2x + invxi2prm_s2x*rho2invLamb
Hnspt4prm_s2x = Hnspt5*prT4prm_s2x + 2*Hnspt6*pf*pfprm_s2x + Hnspt6prm_s2x*pf**2 + Hnspt7*prsqprm_s2x + Hnspt7prm_s2x*prsq + invrho2*ptheta2prm_s2x + invrho2prm_s2x*ptheta2
Hnspt3prm_s2x = Hnspt4*deltaTprm_s2x + Hnspt4prm_s2x*deltaT
Hnspt2prm_s2x = Hnspt3*rho2prm_s2x + Hnspt3prm_s2x*rho2
Hnspt1prm_s2x = pf*wwprm_s2x + pfprm_s2x*ww
Hnsprm_s2x = Hnspt1*invLambprm_s2x + Hnspt1prm_s2x*invLamb + sp.sqrt(Hnspt2*invLamb)*(Hnspt2*invLambprm_s2x/2 + Hnspt2prm_s2x*invLamb/2)/(Hnspt2*invLamb)
Qpt3prm_s2x = deltaR*invrho2prm_s2x + deltaRprm_s2x*invrho2
Qpt2prm_s2x = invxi2*rho2invLambprm_s2x + invxi2prm_s2x*rho2invLamb
Qpt1prm_s2x = invrho2*invxi2prm_s2x + invrho2prm_s2x*invxi2
Qprm_s2x = Qpt1*pvrsqprm_s2x + Qpt1prm_s2x*pvrsq + Qpt2*pxirsqprm_s2x + Qpt2prm_s2x*pxirsq + Qpt3*pnsqprm_s2x + Qpt3prm_s2x*pnsq
pn2prm_s2x = deltaR*invrho2*prsqprm_s2x + deltaR*invrho2prm_s2x*prsq + deltaRprm_s2x*invrho2*prsq
ppprm_s2x = Qprm_s2x
sKerrmultfactprm_s2x = r*(-36*pn2prm_s2x + 3*ppprm_s2x)
sStarmultfactprm_s2x = r*(-30*pn2prm_s2x + 4*ppprm_s2x)
deltaSigmaStarUSCOREx1prm_s2x = etaover12r*(sKerrUSCOREx*sKerrmultfactprm_s2x + sKerrUSCORExprm_s2x*sKerrmultfact + sStarUSCOREx*sStarmultfactprm_s2x + sStarUSCORExprm_s2x*sStarmultfact)
deltaSigmaStarUSCOREy1prm_s2x = etaover12r*(sKerrUSCOREy*sKerrmultfactprm_s2x + sStarUSCOREy*sStarmultfactprm_s2x)
deltaSigmaStarUSCOREz1prm_s2x = etaover12r*(sKerrUSCOREz*sKerrmultfactprm_s2x + sStarUSCOREz*sStarmultfactprm_s2x)
pn2ppprm_s2x = pn2*ppprm_s2x + pn2prm_s2x*pp
pp2prm_s2x = 2*pp*ppprm_s2x
pn2u2prm_s2x = pn2prm_s2x*u2
ppu2prm_s2x = ppprm_s2x*u2
pn2ppu2prm_s2x = pn2ppprm_s2x*u2
sMultiplier1pt6prm_s2x = -720*pn2*pn2prm_s2x + 126*pn2ppprm_s2x + 3*pp2prm_s2x
sMultiplier1pt5prm_s2x = -96*pn2ppprm_s2x + 23*pp2prm_s2x
sMultiplier1pt4prm_s2x = 324*pn2prm_s2x - 120*ppprm_s2x + r*sMultiplier1pt6prm_s2x
sMultiplier1pt3prm_s2x = -282*pn2prm_s2x + 206*ppprm_s2x + r*sMultiplier1pt5prm_s2x
sMultiplier1pt2prm_s2x = r*sMultiplier1pt4prm_s2x
sMultiplier1pt1prm_s2x = eta*sMultiplier1pt2prm_s2x + r*sMultiplier1pt3prm_s2x
sMultiplier1prm_s2x = -eta*sMultiplier1pt1prm_s2x*u2/72
sMultiplier2pt6prm_s2x = 45*pn2*pn2u2prm_s2x/8 - 13*pn2ppu2prm_s2x/8 + 45*pn2prm_s2x*pn2u2/8
sMultiplier2pt5prm_s2x = pn2ppu2prm_s2x/4 - 5*pp2prm_s2x*u2/16
sMultiplier2pt4prm_s2x = -49*pn2u2prm_s2x/8 + 17*ppu2prm_s2x/12 + r*sMultiplier2pt6prm_s2x
sMultiplier2pt3prm_s2x = -2*pn2u2prm_s2x/3 - 109*ppu2prm_s2x/36 + r*sMultiplier2pt5prm_s2x
sMultiplier2pt2prm_s2x = r*sMultiplier2pt4prm_s2x
sMultiplier2pt1prm_s2x = eta*sMultiplier2pt2prm_s2x + r*sMultiplier2pt3prm_s2x
sMultiplier2prm_s2x = eta*sMultiplier2pt1prm_s2x
deltaSigmaStarUSCOREx2prm_s2x = deltaSigmaStarUSCOREx1prm_s2x + sMultiplier1*sigmaStar0prm_s2x + sMultiplier1prm_s2x*sigmaStar0 + sMultiplier2*sigmaKerr0prm_s2x + sMultiplier2prm_s2x*sigmaKerr0
deltaSigmaStarUSCOREy2prm_s2x = deltaSigmaStarUSCOREy1prm_s2x + sMultiplier1prm_s2x*sigmaStar1 + sMultiplier2prm_s2x*sigmaKerr1
deltaSigmaStarUSCOREz2prm_s2x = deltaSigmaStarUSCOREz1prm_s2x + sMultiplier1prm_s2x*sigmaStar2 + sMultiplier2prm_s2x*sigmaKerr2
deltaSigmaStarUSCORExprm_s2x = d1v2*etau3*sigmaKerr0prm_s2x + deltaSigmaStarUSCOREx2prm_s2x
deltaSigmaStarUSCOREyprm_s2x = deltaSigmaStarUSCOREy2prm_s2x
deltaSigmaStarUSCOREzprm_s2x = deltaSigmaStarUSCOREz2prm_s2x
sxprm_s2x = deltaSigmaStarUSCORExprm_s2x + sStarUSCORExprm_s2x
syprm_s2x = deltaSigmaStarUSCOREyprm_s2x
szprm_s2x = deltaSigmaStarUSCOREzprm_s2x
sxiprm_s2x = sx*xiUSCORExprm_s2x + sxprm_s2x*xiUSCOREx + sy*xiUSCOREyprm_s2x + syprm_s2x*xiUSCOREy + sz*xiUSCOREzprm_s2x + szprm_s2x*xiUSCOREz
svprm_s2x = sx*vxprm_s2x + sxprm_s2x*vx + sy*vyprm_s2x + syprm_s2x*vy + sz*vzprm_s2x + szprm_s2x*vz
snprm_s2x = nx*sxprm_s2x + ny*syprm_s2x + nz*szprm_s2x
s3prm_s2x = e3USCOREx*sxprm_s2x + e3USCORExprm_s2x*sx + e3USCOREy*syprm_s2x + e3USCOREyprm_s2x*sy + e3USCOREz*szprm_s2x + e3USCOREzprm_s2x*sz
sqrtQprm_s2x = Qprm_s2x/(2*sp.sqrt(Q))
oneplus2sqrtQprm_s2x = 2*sqrtQprm_s2x
oneplus1sqrtQprm_s2x = oneplus2sqrtQprm_s2x - sqrtQprm_s2x
twoB1psqrtQsqrtQprm_s2x = 2*B*oneplus1sqrtQ*sqrtQprm_s2x + 2*B*oneplus1sqrtQprm_s2x*sqrtQ + 2*Bprm_s2x*oneplus1sqrtQ*sqrtQ
invtwoB1psqrtQsqrtQprm_s2x = -twoB1psqrtQsqrtQprm_s2x/twoB1psqrtQsqrtQ**2
expMUsqsqrtQplusQprm_s2x = expMUsq*(Qprm_s2x + sqrtQprm_s2x) + expMUsqprm_s2x*(Q + sqrtQ)
Hwrpt4aprm_s2x = pxirsq*svprm_s2x + pxirsqprm_s2x*sv
Hwrpt4prm_s2x = Hwrpt4a*expMUsqexpnusqprm_s2x + Hwrpt4aprm_s2x*expMUsqexpnusq
Hwrpt3cprm_s2x = pxir*sxiprm_s2x + pxirprm_s2x*sxi
Hwrpt3bprm_s2x = Hwrpt3c*pvrprm_s2x + Hwrpt3cprm_s2x*pvr
Hwrpt3aprm_s2x = Hwrpt3b*expMUexpnuprm_s2x + Hwrpt3bprm_s2x*expMUexpnu
Hwrpt3prm_s2x = B*Hwrpt3aprm_s2x + Bprm_s2x*Hwrpt3a
Hwrpt2gprm_s2x = deltaR*svprm_s2x + deltaRprm_s2x*sv
Hwrpt2fprm_s2x = sn*sqrtdeltaRprm_s2x + snprm_s2x*sqrtdeltaR
Hwrpt2eprm_s2x = Hwrpt2f*pvrprm_s2x + Hwrpt2fprm_s2x*pvr
Hwrpt2dprm_s2x = Hwrpt2g*pnsqprm_s2x + Hwrpt2gprm_s2x*pnsq
Hwrpt2cprm_s2x = Hwrpt2e*pnprm_s2x + Hwrpt2eprm_s2x*pn
Hwrpt2bprm_s2x = expMUsqsqrtQplusQ*svprm_s2x + expMUsqsqrtQplusQprm_s2x*sv
Hwrpt2aprm_s2x = xi2*(Hwrpt2bprm_s2x + Hwrpt2cprm_s2x - Hwrpt2dprm_s2x) + xi2prm_s2x*(Hwrpt2b + Hwrpt2c - Hwrpt2d)
Hwrpt2prm_s2x = Hwrpt2a*deltaTprm_s2x + Hwrpt2aprm_s2x*deltaT
Hwrpt1bprm_s2x = invtwoB1psqrtQsqrtQ*invxi2prm_s2x + invtwoB1psqrtQsqrtQprm_s2x*invxi2
Hwrpt1aprm_s2x = Hwrpt1b*sqrtdeltaRprm_s2x + Hwrpt1bprm_s2x*sqrtdeltaR
Hwrpt1prm_s2x = Hwrpt1a*invexpMUcubinvexpnuprm_s2x + Hwrpt1aprm_s2x*invexpMUcubinvexpnu
Hwrprm_s2x = Hwrpt1*(Hwrpt2prm_s2x - Hwrpt3prm_s2x + Hwrpt4prm_s2x) + Hwrpt1prm_s2x*(Hwrpt2 - Hwrpt3 + Hwrpt4)
Hwcospt9prm_s2x = pxir*sxiprm_s2x + pxirprm_s2x*sxi
Hwcospt8prm_s2x = pvr*svprm_s2x + pvrprm_s2x*sv
Hwcospt7prm_s2x = B*Hwcospt8prm_s2x + Bprm_s2x*Hwcospt8 - Hwcospt9*expMUexpnuprm_s2x - Hwcospt9prm_s2x*expMUexpnu
Hwcospt6prm_s2x = Hwcospt7*sqrtdeltaRprm_s2x + Hwcospt7prm_s2x*sqrtdeltaR
Hwcospt5prm_s2x = -expMUsqsqrtQplusQ*xi2prm_s2x - expMUsqsqrtQplusQprm_s2x*xi2 + pvrsqprm_s2x
Hwcospt4prm_s2x = Hwcospt6*pnprm_s2x + Hwcospt6prm_s2x*pn
Hwcospt3prm_s2x = Hwcospt5*deltaTprm_s2x + Hwcospt5prm_s2x*deltaT - expMUsqexpnusq*pxirsqprm_s2x - expMUsqexpnusqprm_s2x*pxirsq
Hwcospt2prm_s2x = -B*Hwcospt4prm_s2x - Bprm_s2x*Hwcospt4 + Hwcospt3*snprm_s2x + Hwcospt3prm_s2x*sn
Hwcospt1prm_s2x = Hwcospt2*invexpMUcubinvexpnuprm_s2x + Hwcospt2prm_s2x*invexpMUcubinvexpnu
Hwcosprm_s2x = Hwcospt1*invtwoB1psqrtQsqrtQprm_s2x + Hwcospt1prm_s2x*invtwoB1psqrtQsqrtQ
deltaTsqrtQprm_s2x = deltaT*sqrtQprm_s2x + deltaTprm_s2x*sqrtQ
invdeltatTsqrtQprm_s2x = -deltaTsqrtQprm_s2x/deltaTsqrtQ**2
HSOLpt5prm_s2x = pxir*(-Bprm_s2x + expMUexpnuprm_s2x) + pxirprm_s2x*(-B + expMUexpnu)
HSOLpt4prm_s2x = HSOLpt5*invexpMUprm_s2x + HSOLpt5prm_s2x*invexpMU
HSOLpt3prm_s2x = HSOLpt4*expnusqprm_s2x + HSOLpt4prm_s2x*expnusq
HSOLpt2prm_s2x = HSOLpt3*s3prm_s2x + HSOLpt3prm_s2x*s3
HSOLpt1prm_s2x = HSOLpt2*invxi2prm_s2x + HSOLpt2prm_s2x*invxi2
HSOLprm_s2x = HSOLpt1*invdeltatTsqrtQprm_s2x + HSOLpt1prm_s2x*invdeltatTsqrtQ
deltaTsqrtQplusQprm_s2x = deltaT*(Qprm_s2x + sqrtQprm_s2x) + deltaTprm_s2x*(Q + sqrtQ)
invdeltaTsqrtQplusQprm_s2x = -deltaTsqrtQplusQprm_s2x/deltaTsqrtQplusQ**2
HSONLmult2prm_s2x = invdeltaTsqrtQplusQ*invxi2prm_s2x + invdeltaTsqrtQplusQprm_s2x*invxi2
HSONLmultprm_s2x = HSONLmult2*expnuinvexpMU2prm_s2x + HSONLmult2prm_s2x*expnuinvexpMU2
HSONLpt1bprm_s2x = pn*xi2prm_s2x + pnprm_s2x*xi2
HSONLpt1aprm_s2x = HSONLpt1b*(-mucosprm_s2x + nucosprm_s2x) + HSONLpt1bprm_s2x*(-mucos + nucos) + mur*pvrprm_s2x + murprm_s2x*pvr - nur*pvrprm_s2x - nurprm_s2x*pvr
HSONLpt1prm_s2x = HSONLpt1a*sqrtQprm_s2x + HSONLpt1aprm_s2x*sqrtQ - HSONLpt1b*mucosprm_s2x - HSONLpt1bprm_s2x*mucos + mur*pvrprm_s2x + murprm_s2x*pvr
HSONLpt2dprm_s2x = nur*pxirprm_s2x + nurprm_s2x*pxir
HSONLpt2cprm_s2x = HSONLpt2d*oneplus2sqrtQprm_s2x + HSONLpt2dprm_s2x*oneplus2sqrtQ
HSONLpt2bprm_s2x = B*sxiprm_s2x + Bprm_s2x*sxi
HSONLpt2aprm_s2x = HSONLpt2c*expMUexpnuprm_s2x + HSONLpt2cprm_s2x*expMUexpnu
HSONLpt2prm_s2x = HSONLpt1*HSONLpt2bprm_s2x + HSONLpt1prm_s2x*HSONLpt2b + HSONLpt2a*svprm_s2x + HSONLpt2aprm_s2x*sv
HSONLpt3cprm_s2x = pxir*svprm_s2x + pxirprm_s2x*sv
HSONLpt3bprm_s2x = HSONLpt3c*oneplus1sqrtQprm_s2x + HSONLpt3cprm_s2x*oneplus1sqrtQ
HSONLpt3aprm_s2x = HSONLpt3b*expMUexpnuprm_s2x + HSONLpt3bprm_s2x*expMUexpnu
HSONLpt3prm_s2x = B*HSONLpt2prm_s2x - BR*HSONLpt3aprm_s2x - BRprm_s2x*HSONLpt3a + Bprm_s2x*HSONLpt2
HSONLpt4eprm_s2x = sn*xi2prm_s2x + snprm_s2x*xi2
HSONLpt4dprm_s2x = HSONLpt4e*oneplus2sqrtQprm_s2x + HSONLpt4eprm_s2x*oneplus2sqrtQ
HSONLpt4cprm_s2x = HSONLpt4d*pxirprm_s2x + HSONLpt4dprm_s2x*pxir
HSONLpt4bprm_s2x = HSONLpt4c*nucosprm_s2x + HSONLpt4cprm_s2x*nucos
HSONLpt4aprm_s2x = HSONLpt4b*expMUexpnuprm_s2x + HSONLpt4bprm_s2x*expMUexpnu
HSONLpt4prm_s2x = -B*HSONLpt4aprm_s2x - Bprm_s2x*HSONLpt4a + HSONLpt3*sqrtdeltaRprm_s2x + HSONLpt3prm_s2x*sqrtdeltaR
HSONLprm_s2x = HSONLmult*HSONLpt4prm_s2x + HSONLmultprm_s2x*HSONLpt4
Hsprm_s2x = HSOLprm_s2x + HSONLprm_s2x + Hwcos*wcosprm_s2x + Hwcosprm_s2x*wcos + Hwr*wrprm_s2x + Hwrprm_s2x*wr + s3*wprm_s2x + s3prm_s2x*w
Hsspt1prm_s2x = 3*sn*snprm_s2x - sx*sxprm_s2x - sy*syprm_s2x - sz*szprm_s2x
Hssprm_s2x = Hsspt1prm_s2x*u3
sKerrdotsStarprm_s2x = sKerrUSCOREx*sStarUSCORExprm_s2x + sKerrUSCORExprm_s2x*sStarUSCOREx
Hpt1prm_s2x = etau4*s2dots2prm_s2x
Hprm_s2x = Hnsprm_s2x + Hpt1prm_s2x*dheffSSv2 + Hsprm_s2x + Hssprm_s2x
Hrealprm_s2x = Hprm_s2x*eta*sp.sign(H)/sp.sqrt(2*eta*(sp.Abs(H) - 1) + 1)
sigmaKerr1prm_s2y = 1
sigmaStar1prm_s2y = m1overm2
s2dots2prm_s2y = 2*s2y
sKerrUSCOREyprm_s2y = sigmaKerr1prm_s2y
sStarUSCOREyprm_s2y = sigmaStar1prm_s2y
a2prm_s2y = 2*sKerrUSCOREy*sKerrUSCOREyprm_s2y
a4prm_s2y = 2*a2*a2prm_s2y
aprm_s2y = a2prm_s2y/(2*sp.sqrt(a2))
invaprm_s2y = -aprm_s2y/a**2
k2prm_s2y = -a2prm_s2y*k0*m1PlusetaKKsq
k2sqprm_s2y = 2*k2*k2prm_s2y
k3prm_s2y = -a2prm_s2y*k1*m1PlusetaKKsq + k1*k2prm_s2y - 2.0*k2prm_s2y*m1PlusetaKK
k4prm_s2y = -1.0*a2*k2prm_s2y*m1PlusetaKKsq + a2prm_s2y*m1PlusetaKKsq*(0.5*k1sq - 1.0*k2) + 0.0833333333333333*k1*(24*k2prm_s2y*m1PlusetaKK + 12*k3prm_s2y) - 1.0*k1sq*k2prm_s2y + 1.0*k2*k2prm_s2y - 2.0*k3prm_s2y*m1PlusetaKK
k5prm_s2y = m1PlusetaKKsq*(a2*(1.0*k1*k2prm_s2y - 1.0*k3prm_s2y) + a2prm_s2y*(1.0*k1*k2 - 0.333333333333333*k1cu - 1.0*k3) - (1.0*k1*k2sqprm_s2y - 1.0*k1*k4prm_s2y - 1.0*k1cu*k2prm_s2y + 1.0*k1sq*k3prm_s2y - 1.0*k2*k3prm_s2y - 1.0*k2prm_s2y*k3)/m1PlusetaKKsq + (4.0*k1*k3prm_s2y - 4.0*k1sq*k2prm_s2y + 2.0*k2sqprm_s2y - 4.0*k4prm_s2y)/(2*m1PlusetaKK))
e3USCORExprm_s2y = invaprm_s2y*sKerrUSCOREx
e3USCOREyprm_s2y = inva*sKerrUSCOREyprm_s2y + invaprm_s2y*sKerrUSCOREy
e3USCOREzprm_s2y = invaprm_s2y*sKerrUSCOREz
costhetaprm_s2y = e3USCORExprm_s2y*nx + e3USCOREyprm_s2y*ny + e3USCOREzprm_s2y*nz
xi2prm_s2y = -2*costheta*costhetaprm_s2y
xiUSCORExprm_s2y = e3USCOREyprm_s2y*nz - e3USCOREzprm_s2y*ny
xiUSCOREyprm_s2y = -e3USCORExprm_s2y*nz + e3USCOREzprm_s2y*nx
xiUSCOREzprm_s2y = e3USCORExprm_s2y*ny - e3USCOREyprm_s2y*nx
vxprm_s2y = ny*xiUSCOREzprm_s2y - nz*xiUSCOREyprm_s2y
vyprm_s2y = -nx*xiUSCOREzprm_s2y + nz*xiUSCORExprm_s2y
vzprm_s2y = nx*xiUSCOREyprm_s2y - ny*xiUSCORExprm_s2y
w2prm_s2y = a2prm_s2y
rho2prm_s2y = 2*a2*costheta*costhetaprm_s2y + a2prm_s2y*costheta**2
bulkprm_s2y = a2prm_s2y*u2
logargprm_s2y = k2prm_s2y*u2 + k3prm_s2y*u3 + k4prm_s2y*u4 + k5prm_s2y*u5
onepluslogargprm_s2y = logargprm_s2y
invonepluslogargprm_s2y = -onepluslogargprm_s2y/onepluslogarg**2
logTermsprm_s2y = eta*onepluslogargprm_s2y*sp.sign(onepluslogarg)/sp.Abs(onepluslogarg)
deltaUprm_s2y = (bulk*logTermsprm_s2y + bulkprm_s2y*logTerms)*sp.sign(bulk*logTerms)
deltaTprm_s2y = deltaUprm_s2y*r2
deltaUUSCOREupt7prm_s2y = k5prm_s2y
deltaUUSCOREupt6prm_s2y = 5*deltaUUSCOREupt7prm_s2y*u + 4*k4prm_s2y
deltaUUSCOREupt5prm_s2y = deltaUUSCOREupt6prm_s2y*u + 3*k3prm_s2y
deltaUUSCOREupt4prm_s2y = deltaUUSCOREupt5prm_s2y*u + 2*k2prm_s2y
deltaUUSCOREupt3prm_s2y = deltaUUSCOREupt4prm_s2y*u
deltaUUSCOREupt2prm_s2y = a2prm_s2y*u
deltaUUSCOREupt1prm_s2y = bulk*deltaUUSCOREupt3prm_s2y*eta + bulkprm_s2y*deltaUUSCOREupt3*eta
deltaUUSCOREuprm_s2y = deltaUUSCOREupt1*invonepluslogargprm_s2y + deltaUUSCOREupt1prm_s2y*invonepluslogarg + 2*deltaUUSCOREupt2*logTermsprm_s2y + 2*deltaUUSCOREupt2prm_s2y*logTerms
deltaTUSCORErprm_s2y = -deltaUUSCOREuprm_s2y + 2*deltaUprm_s2y*r
Lambprm_s2y = (a2*deltaT*xi2prm_s2y + a2*deltaTprm_s2y*xi2 + a2prm_s2y*deltaT*xi2 - 2*w2*w2prm_s2y)*sp.sign(a2*deltaT*xi2 - w2**2)
rho2xi2Lambprm_s2y = Lamb*rho2*xi2prm_s2y + Lamb*rho2prm_s2y*xi2 + Lambprm_s2y*rho2*xi2
invrho2xi2Lambprm_s2y = -rho2xi2Lambprm_s2y/rho2xi2Lamb**2
invrho2prm_s2y = -rho2prm_s2y/rho2**2
invxi2prm_s2y = -xi2prm_s2y/xi2**2
invLambprm_s2y = -Lambprm_s2y/Lamb**2
invLambsqprm_s2y = 2*invLamb*invLambprm_s2y
rho2invLambprm_s2y = invLamb*rho2prm_s2y + invLambprm_s2y*rho2
expnuprm_s2y = sp.sqrt(deltaT*rho2invLamb)*(deltaT*rho2invLambprm_s2y/2 + deltaTprm_s2y*rho2invLamb/2)/(deltaT*rho2invLamb)
expMUprm_s2y = rho2prm_s2y/(2*sp.sqrt(rho2))
expMUexpnuprm_s2y = expMU*expnuprm_s2y + expMUprm_s2y*expnu
expMUsqprm_s2y = 2*expMU*expMUprm_s2y
expnusqprm_s2y = 2*expnu*expnuprm_s2y
expMUsqexpnusqprm_s2y = expMUsq*expnusqprm_s2y + expMUsqprm_s2y*expnusq
invexpnuexpMUprm_s2y = -expMUexpnuprm_s2y/expMUexpnu**2
invexpMUprm_s2y = expnu*invexpnuexpMUprm_s2y + expnuprm_s2y*invexpnuexpMU
invexpMUsqprm_s2y = 2*invexpMU*invexpMUprm_s2y
expnuinvexpMU2prm_s2y = expnu*invexpMUsqprm_s2y + expnuprm_s2y*invexpMUsq
invexpMUcubinvexpnuprm_s2y = invexpMUsq*invexpnuexpMUprm_s2y + invexpMUsqprm_s2y*invexpnuexpMU
deltaRprm_s2y = DD*deltaTprm_s2y
wwprm_s2y = a*a2prm_s2y*b3*eta*u + a2*aprm_s2y*b3*eta*u + aprm_s2y*bb3*eta*u + 2*aprm_s2y*r
Bprm_s2y = deltaTprm_s2y/(2*sp.sqrt(deltaT))
sqrtdeltaTprm_s2y = Bprm_s2y
sqrtdeltaRprm_s2y = deltaRprm_s2y/(2*sp.sqrt(deltaR))
deltaTsqrtdeltaRprm_s2y = deltaT*sqrtdeltaRprm_s2y + deltaTprm_s2y*sqrtdeltaR
sqrtdeltaTdeltaTsqrtdeltaRprm_s2y = deltaTsqrtdeltaR*sqrtdeltaTprm_s2y + deltaTsqrtdeltaRprm_s2y*sqrtdeltaT
invdeltaTsqrtdeltaTsqrtdeltaRprm_s2y = -1.0*sqrtdeltaTdeltaTsqrtdeltaRprm_s2y/sqrtdeltaTdeltaTsqrtdeltaR**2
invdeltaTprm_s2y = invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaR*sqrtdeltaTprm_s2y + invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaRprm_s2y*sqrtdeltaT + invdeltaTsqrtdeltaTsqrtdeltaRprm_s2y*sqrtdeltaR*sqrtdeltaT
invsqrtdeltaTprm_s2y = deltaTsqrtdeltaR*invdeltaTsqrtdeltaTsqrtdeltaRprm_s2y + deltaTsqrtdeltaRprm_s2y*invdeltaTsqrtdeltaTsqrtdeltaR
invsqrtdeltaRprm_s2y = deltaT*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaTprm_s2y + deltaT*invdeltaTsqrtdeltaTsqrtdeltaRprm_s2y*sqrtdeltaT + deltaTprm_s2y*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaT
wprm_s2y = invLamb*wwprm_s2y + invLambprm_s2y*ww
LambUSCORErprm_s2y = -a2*deltaTUSCOREr*xi2prm_s2y - a2*deltaTUSCORErprm_s2y*xi2 - a2prm_s2y*deltaTUSCOREr*xi2 + 4*r*w2prm_s2y
wwUSCORErprm_s2y = -a*a2prm_s2y*b3*eta*u2 - a2*aprm_s2y*b3*eta*u2 - aprm_s2y*bb3*eta*u2 + 2*aprm_s2y
BRprm_s2y = invsqrtdeltaT*(-deltaT*invsqrtdeltaRprm_s2y + deltaTUSCORErprm_s2y/2 - deltaTprm_s2y*invsqrtdeltaR) + invsqrtdeltaTprm_s2y*(-deltaT*invsqrtdeltaR + deltaTUSCOREr/2)
wrprm_s2y = invLambsq*(Lamb*wwUSCORErprm_s2y - LambUSCOREr*wwprm_s2y - LambUSCORErprm_s2y*ww + Lambprm_s2y*wwUSCOREr) + invLambsqprm_s2y*(Lamb*wwUSCOREr - LambUSCOREr*ww)
nurpt2prm_s2y = w2*(deltaTUSCOREr*w2prm_s2y + deltaTUSCORErprm_s2y*w2 - 4.0*deltaTprm_s2y*r) + w2prm_s2y*(-4.0*deltaT*r + deltaTUSCOREr*w2)
nurpt1prm_s2y = invdeltaT*nurpt2prm_s2y + invdeltaTprm_s2y*nurpt2
nurprm_s2y = invLamb*nurpt1prm_s2y/2 + invLambprm_s2y*nurpt1/2 + invrho2prm_s2y*r
murprm_s2y = invrho2prm_s2y*r - invsqrtdeltaRprm_s2y
a2costhetaprm_s2y = a2*costhetaprm_s2y + a2prm_s2y*costheta
wcospt2prm_s2y = deltaT*wwprm_s2y + deltaTprm_s2y*ww
wcospt1prm_s2y = invLambsq*wcospt2prm_s2y + invLambsqprm_s2y*wcospt2
wcosprm_s2y = -2*a2costheta*wcospt1prm_s2y - 2*a2costhetaprm_s2y*wcospt1
nucospt3prm_s2y = invLamb*invrho2prm_s2y + invLambprm_s2y*invrho2
nucospt2prm_s2y = nucospt3*w2prm_s2y + nucospt3prm_s2y*w2
nucospt1prm_s2y = a2costheta*nucospt2prm_s2y + a2costhetaprm_s2y*nucospt2
nucosprm_s2y = nucospt1*(-deltaTprm_s2y + w2prm_s2y) + nucospt1prm_s2y*(-deltaT + w2)
mucosprm_s2y = a2costheta*invrho2prm_s2y + a2costhetaprm_s2y*invrho2
csiprm_s2y = (deltaR*deltaTprm_s2y + deltaRprm_s2y*deltaT)*sp.sign(deltaR*deltaT)/(2*w2*sp.sqrt(sp.Abs(deltaR*deltaT))) - w2prm_s2y*sp.sqrt(sp.Abs(deltaR*deltaT))/w2**2
csi1prm_s2y = csiprm_s2y*(1 - sp.Abs(tortoise - 1))
csi2prm_s2y = csiprm_s2y*(1/2 - 0.5*sp.sign(1.5 - tortoise))
prTprm_s2y = csi2prm_s2y*(nx*px + ny*py + nz*pz)
prTtimesoneminuscsi1invprm_s2y = prTprm_s2y*(1 - 1/csi1) + csi1prm_s2y*prT/csi1**2
tmppxprm_s2y = -nx*prTtimesoneminuscsi1invprm_s2y
tmppyprm_s2y = -ny*prTtimesoneminuscsi1invprm_s2y
tmppzprm_s2y = -nz*prTtimesoneminuscsi1invprm_s2y
pxirprm_s2y = r*(tmppx*xiUSCORExprm_s2y + tmppxprm_s2y*xiUSCOREx + tmppy*xiUSCOREyprm_s2y + tmppyprm_s2y*xiUSCOREy + tmppz*xiUSCOREzprm_s2y + tmppzprm_s2y*xiUSCOREz)
pvrprm_s2y = r*(tmppx*vxprm_s2y + tmppxprm_s2y*vx + tmppy*vyprm_s2y + tmppyprm_s2y*vy + tmppz*vzprm_s2y + tmppzprm_s2y*vz)
pvrsqprm_s2y = 2*pvr*pvrprm_s2y
pnprm_s2y = nx*tmppxprm_s2y + ny*tmppyprm_s2y + nz*tmppzprm_s2y
pnsqprm_s2y = 2*pn*pnprm_s2y
prprm_s2y = pnprm_s2y
prsqprm_s2y = 2*pr*prprm_s2y
pfprm_s2y = pxirprm_s2y
pxirsqprm_s2y = 2*pxir*pxirprm_s2y
ptheta2prm_s2y = invxi2*pvrsqprm_s2y + invxi2prm_s2y*pvrsq
prT4prm_s2y = 4*prT**3*prTprm_s2y
Hnspt7prm_s2y = deltaR*invrho2prm_s2y + deltaRprm_s2y*invrho2
Hnspt6prm_s2y = invxi2*rho2invLambprm_s2y + invxi2prm_s2y*rho2invLamb
Hnspt4prm_s2y = Hnspt5*prT4prm_s2y + 2*Hnspt6*pf*pfprm_s2y + Hnspt6prm_s2y*pf**2 + Hnspt7*prsqprm_s2y + Hnspt7prm_s2y*prsq + invrho2*ptheta2prm_s2y + invrho2prm_s2y*ptheta2
Hnspt3prm_s2y = Hnspt4*deltaTprm_s2y + Hnspt4prm_s2y*deltaT
Hnspt2prm_s2y = Hnspt3*rho2prm_s2y + Hnspt3prm_s2y*rho2
Hnspt1prm_s2y = pf*wwprm_s2y + pfprm_s2y*ww
Hnsprm_s2y = Hnspt1*invLambprm_s2y + Hnspt1prm_s2y*invLamb + sp.sqrt(Hnspt2*invLamb)*(Hnspt2*invLambprm_s2y/2 + Hnspt2prm_s2y*invLamb/2)/(Hnspt2*invLamb)
Qpt3prm_s2y = deltaR*invrho2prm_s2y + deltaRprm_s2y*invrho2
Qpt2prm_s2y = invxi2*rho2invLambprm_s2y + invxi2prm_s2y*rho2invLamb
Qpt1prm_s2y = invrho2*invxi2prm_s2y + invrho2prm_s2y*invxi2
Qprm_s2y = Qpt1*pvrsqprm_s2y + Qpt1prm_s2y*pvrsq + Qpt2*pxirsqprm_s2y + Qpt2prm_s2y*pxirsq + Qpt3*pnsqprm_s2y + Qpt3prm_s2y*pnsq
pn2prm_s2y = deltaR*invrho2*prsqprm_s2y + deltaR*invrho2prm_s2y*prsq + deltaRprm_s2y*invrho2*prsq
ppprm_s2y = Qprm_s2y
sKerrmultfactprm_s2y = r*(-36*pn2prm_s2y + 3*ppprm_s2y)
sStarmultfactprm_s2y = r*(-30*pn2prm_s2y + 4*ppprm_s2y)
deltaSigmaStarUSCOREx1prm_s2y = etaover12r*(sKerrUSCOREx*sKerrmultfactprm_s2y + sStarUSCOREx*sStarmultfactprm_s2y)
deltaSigmaStarUSCOREy1prm_s2y = etaover12r*(sKerrUSCOREy*sKerrmultfactprm_s2y + sKerrUSCOREyprm_s2y*sKerrmultfact + sStarUSCOREy*sStarmultfactprm_s2y + sStarUSCOREyprm_s2y*sStarmultfact)
deltaSigmaStarUSCOREz1prm_s2y = etaover12r*(sKerrUSCOREz*sKerrmultfactprm_s2y + sStarUSCOREz*sStarmultfactprm_s2y)
pn2ppprm_s2y = pn2*ppprm_s2y + pn2prm_s2y*pp
pp2prm_s2y = 2*pp*ppprm_s2y
pn2u2prm_s2y = pn2prm_s2y*u2
ppu2prm_s2y = ppprm_s2y*u2
pn2ppu2prm_s2y = pn2ppprm_s2y*u2
sMultiplier1pt6prm_s2y = -720*pn2*pn2prm_s2y + 126*pn2ppprm_s2y + 3*pp2prm_s2y
sMultiplier1pt5prm_s2y = -96*pn2ppprm_s2y + 23*pp2prm_s2y
sMultiplier1pt4prm_s2y = 324*pn2prm_s2y - 120*ppprm_s2y + r*sMultiplier1pt6prm_s2y
sMultiplier1pt3prm_s2y = -282*pn2prm_s2y + 206*ppprm_s2y + r*sMultiplier1pt5prm_s2y
sMultiplier1pt2prm_s2y = r*sMultiplier1pt4prm_s2y
sMultiplier1pt1prm_s2y = eta*sMultiplier1pt2prm_s2y + r*sMultiplier1pt3prm_s2y
sMultiplier1prm_s2y = -eta*sMultiplier1pt1prm_s2y*u2/72
sMultiplier2pt6prm_s2y = 45*pn2*pn2u2prm_s2y/8 - 13*pn2ppu2prm_s2y/8 + 45*pn2prm_s2y*pn2u2/8
sMultiplier2pt5prm_s2y = pn2ppu2prm_s2y/4 - 5*pp2prm_s2y*u2/16
sMultiplier2pt4prm_s2y = -49*pn2u2prm_s2y/8 + 17*ppu2prm_s2y/12 + r*sMultiplier2pt6prm_s2y
sMultiplier2pt3prm_s2y = -2*pn2u2prm_s2y/3 - 109*ppu2prm_s2y/36 + r*sMultiplier2pt5prm_s2y
sMultiplier2pt2prm_s2y = r*sMultiplier2pt4prm_s2y
sMultiplier2pt1prm_s2y = eta*sMultiplier2pt2prm_s2y + r*sMultiplier2pt3prm_s2y
sMultiplier2prm_s2y = eta*sMultiplier2pt1prm_s2y
deltaSigmaStarUSCOREx2prm_s2y = deltaSigmaStarUSCOREx1prm_s2y + sMultiplier1prm_s2y*sigmaStar0 + sMultiplier2prm_s2y*sigmaKerr0
deltaSigmaStarUSCOREy2prm_s2y = deltaSigmaStarUSCOREy1prm_s2y + sMultiplier1*sigmaStar1prm_s2y + sMultiplier1prm_s2y*sigmaStar1 + sMultiplier2*sigmaKerr1prm_s2y + sMultiplier2prm_s2y*sigmaKerr1
deltaSigmaStarUSCOREz2prm_s2y = deltaSigmaStarUSCOREz1prm_s2y + sMultiplier1prm_s2y*sigmaStar2 + sMultiplier2prm_s2y*sigmaKerr2
deltaSigmaStarUSCORExprm_s2y = deltaSigmaStarUSCOREx2prm_s2y
deltaSigmaStarUSCOREyprm_s2y = d1v2*etau3*sigmaKerr1prm_s2y + deltaSigmaStarUSCOREy2prm_s2y
deltaSigmaStarUSCOREzprm_s2y = deltaSigmaStarUSCOREz2prm_s2y
sxprm_s2y = deltaSigmaStarUSCORExprm_s2y
syprm_s2y = deltaSigmaStarUSCOREyprm_s2y + sStarUSCOREyprm_s2y
szprm_s2y = deltaSigmaStarUSCOREzprm_s2y
sxiprm_s2y = sx*xiUSCORExprm_s2y + sxprm_s2y*xiUSCOREx + sy*xiUSCOREyprm_s2y + syprm_s2y*xiUSCOREy + sz*xiUSCOREzprm_s2y + szprm_s2y*xiUSCOREz
svprm_s2y = sx*vxprm_s2y + sxprm_s2y*vx + sy*vyprm_s2y + syprm_s2y*vy + sz*vzprm_s2y + szprm_s2y*vz
snprm_s2y = nx*sxprm_s2y + ny*syprm_s2y + nz*szprm_s2y
s3prm_s2y = e3USCOREx*sxprm_s2y + e3USCORExprm_s2y*sx + e3USCOREy*syprm_s2y + e3USCOREyprm_s2y*sy + e3USCOREz*szprm_s2y + e3USCOREzprm_s2y*sz
sqrtQprm_s2y = Qprm_s2y/(2*sp.sqrt(Q))
oneplus2sqrtQprm_s2y = 2*sqrtQprm_s2y
oneplus1sqrtQprm_s2y = oneplus2sqrtQprm_s2y - sqrtQprm_s2y
twoB1psqrtQsqrtQprm_s2y = 2*B*oneplus1sqrtQ*sqrtQprm_s2y + 2*B*oneplus1sqrtQprm_s2y*sqrtQ + 2*Bprm_s2y*oneplus1sqrtQ*sqrtQ
invtwoB1psqrtQsqrtQprm_s2y = -twoB1psqrtQsqrtQprm_s2y/twoB1psqrtQsqrtQ**2
expMUsqsqrtQplusQprm_s2y = expMUsq*(Qprm_s2y + sqrtQprm_s2y) + expMUsqprm_s2y*(Q + sqrtQ)
Hwrpt4aprm_s2y = pxirsq*svprm_s2y + pxirsqprm_s2y*sv
Hwrpt4prm_s2y = Hwrpt4a*expMUsqexpnusqprm_s2y + Hwrpt4aprm_s2y*expMUsqexpnusq
Hwrpt3cprm_s2y = pxir*sxiprm_s2y + pxirprm_s2y*sxi
Hwrpt3bprm_s2y = Hwrpt3c*pvrprm_s2y + Hwrpt3cprm_s2y*pvr
Hwrpt3aprm_s2y = Hwrpt3b*expMUexpnuprm_s2y + Hwrpt3bprm_s2y*expMUexpnu
Hwrpt3prm_s2y = B*Hwrpt3aprm_s2y + Bprm_s2y*Hwrpt3a
Hwrpt2gprm_s2y = deltaR*svprm_s2y + deltaRprm_s2y*sv
Hwrpt2fprm_s2y = sn*sqrtdeltaRprm_s2y + snprm_s2y*sqrtdeltaR
Hwrpt2eprm_s2y = Hwrpt2f*pvrprm_s2y + Hwrpt2fprm_s2y*pvr
Hwrpt2dprm_s2y = Hwrpt2g*pnsqprm_s2y + Hwrpt2gprm_s2y*pnsq
Hwrpt2cprm_s2y = Hwrpt2e*pnprm_s2y + Hwrpt2eprm_s2y*pn
Hwrpt2bprm_s2y = expMUsqsqrtQplusQ*svprm_s2y + expMUsqsqrtQplusQprm_s2y*sv
Hwrpt2aprm_s2y = xi2*(Hwrpt2bprm_s2y + Hwrpt2cprm_s2y - Hwrpt2dprm_s2y) + xi2prm_s2y*(Hwrpt2b + Hwrpt2c - Hwrpt2d)
Hwrpt2prm_s2y = Hwrpt2a*deltaTprm_s2y + Hwrpt2aprm_s2y*deltaT
Hwrpt1bprm_s2y = invtwoB1psqrtQsqrtQ*invxi2prm_s2y + invtwoB1psqrtQsqrtQprm_s2y*invxi2
Hwrpt1aprm_s2y = Hwrpt1b*sqrtdeltaRprm_s2y + Hwrpt1bprm_s2y*sqrtdeltaR
Hwrpt1prm_s2y = Hwrpt1a*invexpMUcubinvexpnuprm_s2y + Hwrpt1aprm_s2y*invexpMUcubinvexpnu
Hwrprm_s2y = Hwrpt1*(Hwrpt2prm_s2y - Hwrpt3prm_s2y + Hwrpt4prm_s2y) + Hwrpt1prm_s2y*(Hwrpt2 - Hwrpt3 + Hwrpt4)
Hwcospt9prm_s2y = pxir*sxiprm_s2y + pxirprm_s2y*sxi
Hwcospt8prm_s2y = pvr*svprm_s2y + pvrprm_s2y*sv
Hwcospt7prm_s2y = B*Hwcospt8prm_s2y + Bprm_s2y*Hwcospt8 - Hwcospt9*expMUexpnuprm_s2y - Hwcospt9prm_s2y*expMUexpnu
Hwcospt6prm_s2y = Hwcospt7*sqrtdeltaRprm_s2y + Hwcospt7prm_s2y*sqrtdeltaR
Hwcospt5prm_s2y = -expMUsqsqrtQplusQ*xi2prm_s2y - expMUsqsqrtQplusQprm_s2y*xi2 + pvrsqprm_s2y
Hwcospt4prm_s2y = Hwcospt6*pnprm_s2y + Hwcospt6prm_s2y*pn
Hwcospt3prm_s2y = Hwcospt5*deltaTprm_s2y + Hwcospt5prm_s2y*deltaT - expMUsqexpnusq*pxirsqprm_s2y - expMUsqexpnusqprm_s2y*pxirsq
Hwcospt2prm_s2y = -B*Hwcospt4prm_s2y - Bprm_s2y*Hwcospt4 + Hwcospt3*snprm_s2y + Hwcospt3prm_s2y*sn
Hwcospt1prm_s2y = Hwcospt2*invexpMUcubinvexpnuprm_s2y + Hwcospt2prm_s2y*invexpMUcubinvexpnu
Hwcosprm_s2y = Hwcospt1*invtwoB1psqrtQsqrtQprm_s2y + Hwcospt1prm_s2y*invtwoB1psqrtQsqrtQ
deltaTsqrtQprm_s2y = deltaT*sqrtQprm_s2y + deltaTprm_s2y*sqrtQ
invdeltatTsqrtQprm_s2y = -deltaTsqrtQprm_s2y/deltaTsqrtQ**2
HSOLpt5prm_s2y = pxir*(-Bprm_s2y + expMUexpnuprm_s2y) + pxirprm_s2y*(-B + expMUexpnu)
HSOLpt4prm_s2y = HSOLpt5*invexpMUprm_s2y + HSOLpt5prm_s2y*invexpMU
HSOLpt3prm_s2y = HSOLpt4*expnusqprm_s2y + HSOLpt4prm_s2y*expnusq
HSOLpt2prm_s2y = HSOLpt3*s3prm_s2y + HSOLpt3prm_s2y*s3
HSOLpt1prm_s2y = HSOLpt2*invxi2prm_s2y + HSOLpt2prm_s2y*invxi2
HSOLprm_s2y = HSOLpt1*invdeltatTsqrtQprm_s2y + HSOLpt1prm_s2y*invdeltatTsqrtQ
deltaTsqrtQplusQprm_s2y = deltaT*(Qprm_s2y + sqrtQprm_s2y) + deltaTprm_s2y*(Q + sqrtQ)
invdeltaTsqrtQplusQprm_s2y = -deltaTsqrtQplusQprm_s2y/deltaTsqrtQplusQ**2
HSONLmult2prm_s2y = invdeltaTsqrtQplusQ*invxi2prm_s2y + invdeltaTsqrtQplusQprm_s2y*invxi2
HSONLmultprm_s2y = HSONLmult2*expnuinvexpMU2prm_s2y + HSONLmult2prm_s2y*expnuinvexpMU2
HSONLpt1bprm_s2y = pn*xi2prm_s2y + pnprm_s2y*xi2
HSONLpt1aprm_s2y = HSONLpt1b*(-mucosprm_s2y + nucosprm_s2y) + HSONLpt1bprm_s2y*(-mucos + nucos) + mur*pvrprm_s2y + murprm_s2y*pvr - nur*pvrprm_s2y - nurprm_s2y*pvr
HSONLpt1prm_s2y = HSONLpt1a*sqrtQprm_s2y + HSONLpt1aprm_s2y*sqrtQ - HSONLpt1b*mucosprm_s2y - HSONLpt1bprm_s2y*mucos + mur*pvrprm_s2y + murprm_s2y*pvr
HSONLpt2dprm_s2y = nur*pxirprm_s2y + nurprm_s2y*pxir
HSONLpt2cprm_s2y = HSONLpt2d*oneplus2sqrtQprm_s2y + HSONLpt2dprm_s2y*oneplus2sqrtQ
HSONLpt2bprm_s2y = B*sxiprm_s2y + Bprm_s2y*sxi
HSONLpt2aprm_s2y = HSONLpt2c*expMUexpnuprm_s2y + HSONLpt2cprm_s2y*expMUexpnu
HSONLpt2prm_s2y = HSONLpt1*HSONLpt2bprm_s2y + HSONLpt1prm_s2y*HSONLpt2b + HSONLpt2a*svprm_s2y + HSONLpt2aprm_s2y*sv
HSONLpt3cprm_s2y = pxir*svprm_s2y + pxirprm_s2y*sv
HSONLpt3bprm_s2y = HSONLpt3c*oneplus1sqrtQprm_s2y + HSONLpt3cprm_s2y*oneplus1sqrtQ
HSONLpt3aprm_s2y = HSONLpt3b*expMUexpnuprm_s2y + HSONLpt3bprm_s2y*expMUexpnu
HSONLpt3prm_s2y = B*HSONLpt2prm_s2y - BR*HSONLpt3aprm_s2y - BRprm_s2y*HSONLpt3a + Bprm_s2y*HSONLpt2
HSONLpt4eprm_s2y = sn*xi2prm_s2y + snprm_s2y*xi2
HSONLpt4dprm_s2y = HSONLpt4e*oneplus2sqrtQprm_s2y + HSONLpt4eprm_s2y*oneplus2sqrtQ
HSONLpt4cprm_s2y = HSONLpt4d*pxirprm_s2y + HSONLpt4dprm_s2y*pxir
HSONLpt4bprm_s2y = HSONLpt4c*nucosprm_s2y + HSONLpt4cprm_s2y*nucos
HSONLpt4aprm_s2y = HSONLpt4b*expMUexpnuprm_s2y + HSONLpt4bprm_s2y*expMUexpnu
HSONLpt4prm_s2y = -B*HSONLpt4aprm_s2y - Bprm_s2y*HSONLpt4a + HSONLpt3*sqrtdeltaRprm_s2y + HSONLpt3prm_s2y*sqrtdeltaR
HSONLprm_s2y = HSONLmult*HSONLpt4prm_s2y + HSONLmultprm_s2y*HSONLpt4
Hsprm_s2y = HSOLprm_s2y + HSONLprm_s2y + Hwcos*wcosprm_s2y + Hwcosprm_s2y*wcos + Hwr*wrprm_s2y + Hwrprm_s2y*wr + s3*wprm_s2y + s3prm_s2y*w
Hsspt1prm_s2y = 3*sn*snprm_s2y - sx*sxprm_s2y - sy*syprm_s2y - sz*szprm_s2y
Hssprm_s2y = Hsspt1prm_s2y*u3
sKerrdotsStarprm_s2y = sKerrUSCOREy*sStarUSCOREyprm_s2y + sKerrUSCOREyprm_s2y*sStarUSCOREy
Hpt1prm_s2y = etau4*s2dots2prm_s2y
Hprm_s2y = Hnsprm_s2y + Hpt1prm_s2y*dheffSSv2 + Hsprm_s2y + Hssprm_s2y
Hrealprm_s2y = Hprm_s2y*eta*sp.sign(H)/sp.sqrt(2*eta*(sp.Abs(H) - 1) + 1)
sigmaKerr2prm_s2z = 1
sigmaStar2prm_s2z = m1overm2
s2dots2prm_s2z = 2*s2z
sKerrUSCOREzprm_s2z = sigmaKerr2prm_s2z
sStarUSCOREzprm_s2z = sigmaStar2prm_s2z
a2prm_s2z = 2*sKerrUSCOREz*sKerrUSCOREzprm_s2z
a4prm_s2z = 2*a2*a2prm_s2z
aprm_s2z = a2prm_s2z/(2*sp.sqrt(a2))
invaprm_s2z = -aprm_s2z/a**2
k2prm_s2z = -a2prm_s2z*k0*m1PlusetaKKsq
k2sqprm_s2z = 2*k2*k2prm_s2z
k3prm_s2z = -a2prm_s2z*k1*m1PlusetaKKsq + k1*k2prm_s2z - 2.0*k2prm_s2z*m1PlusetaKK
k4prm_s2z = -1.0*a2*k2prm_s2z*m1PlusetaKKsq + a2prm_s2z*m1PlusetaKKsq*(0.5*k1sq - 1.0*k2) + 0.0833333333333333*k1*(24*k2prm_s2z*m1PlusetaKK + 12*k3prm_s2z) - 1.0*k1sq*k2prm_s2z + 1.0*k2*k2prm_s2z - 2.0*k3prm_s2z*m1PlusetaKK
k5prm_s2z = m1PlusetaKKsq*(a2*(1.0*k1*k2prm_s2z - 1.0*k3prm_s2z) + a2prm_s2z*(1.0*k1*k2 - 0.333333333333333*k1cu - 1.0*k3) - (1.0*k1*k2sqprm_s2z - 1.0*k1*k4prm_s2z - 1.0*k1cu*k2prm_s2z + 1.0*k1sq*k3prm_s2z - 1.0*k2*k3prm_s2z - 1.0*k2prm_s2z*k3)/m1PlusetaKKsq + (4.0*k1*k3prm_s2z - 4.0*k1sq*k2prm_s2z + 2.0*k2sqprm_s2z - 4.0*k4prm_s2z)/(2*m1PlusetaKK))
e3USCORExprm_s2z = invaprm_s2z*sKerrUSCOREx
e3USCOREyprm_s2z = invaprm_s2z*sKerrUSCOREy
e3USCOREzprm_s2z = inva*sKerrUSCOREzprm_s2z + invaprm_s2z*sKerrUSCOREz
costhetaprm_s2z = e3USCORExprm_s2z*nx + e3USCOREyprm_s2z*ny + e3USCOREzprm_s2z*nz
xi2prm_s2z = -2*costheta*costhetaprm_s2z
xiUSCORExprm_s2z = e3USCOREyprm_s2z*nz - e3USCOREzprm_s2z*ny
xiUSCOREyprm_s2z = -e3USCORExprm_s2z*nz + e3USCOREzprm_s2z*nx
xiUSCOREzprm_s2z = e3USCORExprm_s2z*ny - e3USCOREyprm_s2z*nx
vxprm_s2z = ny*xiUSCOREzprm_s2z - nz*xiUSCOREyprm_s2z
vyprm_s2z = -nx*xiUSCOREzprm_s2z + nz*xiUSCORExprm_s2z
vzprm_s2z = nx*xiUSCOREyprm_s2z - ny*xiUSCORExprm_s2z
w2prm_s2z = a2prm_s2z
rho2prm_s2z = 2*a2*costheta*costhetaprm_s2z + a2prm_s2z*costheta**2
bulkprm_s2z = a2prm_s2z*u2
logargprm_s2z = k2prm_s2z*u2 + k3prm_s2z*u3 + k4prm_s2z*u4 + k5prm_s2z*u5
onepluslogargprm_s2z = logargprm_s2z
invonepluslogargprm_s2z = -onepluslogargprm_s2z/onepluslogarg**2
logTermsprm_s2z = eta*onepluslogargprm_s2z*sp.sign(onepluslogarg)/sp.Abs(onepluslogarg)
deltaUprm_s2z = (bulk*logTermsprm_s2z + bulkprm_s2z*logTerms)*sp.sign(bulk*logTerms)
deltaTprm_s2z = deltaUprm_s2z*r2
deltaUUSCOREupt7prm_s2z = k5prm_s2z
deltaUUSCOREupt6prm_s2z = 5*deltaUUSCOREupt7prm_s2z*u + 4*k4prm_s2z
deltaUUSCOREupt5prm_s2z = deltaUUSCOREupt6prm_s2z*u + 3*k3prm_s2z
deltaUUSCOREupt4prm_s2z = deltaUUSCOREupt5prm_s2z*u + 2*k2prm_s2z
deltaUUSCOREupt3prm_s2z = deltaUUSCOREupt4prm_s2z*u
deltaUUSCOREupt2prm_s2z = a2prm_s2z*u
deltaUUSCOREupt1prm_s2z = bulk*deltaUUSCOREupt3prm_s2z*eta + bulkprm_s2z*deltaUUSCOREupt3*eta
deltaUUSCOREuprm_s2z = deltaUUSCOREupt1*invonepluslogargprm_s2z + deltaUUSCOREupt1prm_s2z*invonepluslogarg + 2*deltaUUSCOREupt2*logTermsprm_s2z + 2*deltaUUSCOREupt2prm_s2z*logTerms
deltaTUSCORErprm_s2z = -deltaUUSCOREuprm_s2z + 2*deltaUprm_s2z*r
Lambprm_s2z = (a2*deltaT*xi2prm_s2z + a2*deltaTprm_s2z*xi2 + a2prm_s2z*deltaT*xi2 - 2*w2*w2prm_s2z)*sp.sign(a2*deltaT*xi2 - w2**2)
rho2xi2Lambprm_s2z = Lamb*rho2*xi2prm_s2z + Lamb*rho2prm_s2z*xi2 + Lambprm_s2z*rho2*xi2
invrho2xi2Lambprm_s2z = -rho2xi2Lambprm_s2z/rho2xi2Lamb**2
invrho2prm_s2z = -rho2prm_s2z/rho2**2
invxi2prm_s2z = -xi2prm_s2z/xi2**2
invLambprm_s2z = -Lambprm_s2z/Lamb**2
invLambsqprm_s2z = 2*invLamb*invLambprm_s2z
rho2invLambprm_s2z = invLamb*rho2prm_s2z + invLambprm_s2z*rho2
expnuprm_s2z = sp.sqrt(deltaT*rho2invLamb)*(deltaT*rho2invLambprm_s2z/2 + deltaTprm_s2z*rho2invLamb/2)/(deltaT*rho2invLamb)
expMUprm_s2z = rho2prm_s2z/(2*sp.sqrt(rho2))
expMUexpnuprm_s2z = expMU*expnuprm_s2z + expMUprm_s2z*expnu
expMUsqprm_s2z = 2*expMU*expMUprm_s2z
expnusqprm_s2z = 2*expnu*expnuprm_s2z
expMUsqexpnusqprm_s2z = expMUsq*expnusqprm_s2z + expMUsqprm_s2z*expnusq
invexpnuexpMUprm_s2z = -expMUexpnuprm_s2z/expMUexpnu**2
invexpMUprm_s2z = expnu*invexpnuexpMUprm_s2z + expnuprm_s2z*invexpnuexpMU
invexpMUsqprm_s2z = 2*invexpMU*invexpMUprm_s2z
expnuinvexpMU2prm_s2z = expnu*invexpMUsqprm_s2z + expnuprm_s2z*invexpMUsq
invexpMUcubinvexpnuprm_s2z = invexpMUsq*invexpnuexpMUprm_s2z + invexpMUsqprm_s2z*invexpnuexpMU
deltaRprm_s2z = DD*deltaTprm_s2z
wwprm_s2z = a*a2prm_s2z*b3*eta*u + a2*aprm_s2z*b3*eta*u + aprm_s2z*bb3*eta*u + 2*aprm_s2z*r
Bprm_s2z = deltaTprm_s2z/(2*sp.sqrt(deltaT))
sqrtdeltaTprm_s2z = Bprm_s2z
sqrtdeltaRprm_s2z = deltaRprm_s2z/(2*sp.sqrt(deltaR))
deltaTsqrtdeltaRprm_s2z = deltaT*sqrtdeltaRprm_s2z + deltaTprm_s2z*sqrtdeltaR
sqrtdeltaTdeltaTsqrtdeltaRprm_s2z = deltaTsqrtdeltaR*sqrtdeltaTprm_s2z + deltaTsqrtdeltaRprm_s2z*sqrtdeltaT
invdeltaTsqrtdeltaTsqrtdeltaRprm_s2z = -1.0*sqrtdeltaTdeltaTsqrtdeltaRprm_s2z/sqrtdeltaTdeltaTsqrtdeltaR**2
invdeltaTprm_s2z = invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaR*sqrtdeltaTprm_s2z + invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaRprm_s2z*sqrtdeltaT + invdeltaTsqrtdeltaTsqrtdeltaRprm_s2z*sqrtdeltaR*sqrtdeltaT
invsqrtdeltaTprm_s2z = deltaTsqrtdeltaR*invdeltaTsqrtdeltaTsqrtdeltaRprm_s2z + deltaTsqrtdeltaRprm_s2z*invdeltaTsqrtdeltaTsqrtdeltaR
invsqrtdeltaRprm_s2z = deltaT*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaTprm_s2z + deltaT*invdeltaTsqrtdeltaTsqrtdeltaRprm_s2z*sqrtdeltaT + deltaTprm_s2z*invdeltaTsqrtdeltaTsqrtdeltaR*sqrtdeltaT
wprm_s2z = invLamb*wwprm_s2z + invLambprm_s2z*ww
LambUSCORErprm_s2z = -a2*deltaTUSCOREr*xi2prm_s2z - a2*deltaTUSCORErprm_s2z*xi2 - a2prm_s2z*deltaTUSCOREr*xi2 + 4*r*w2prm_s2z
wwUSCORErprm_s2z = -a*a2prm_s2z*b3*eta*u2 - a2*aprm_s2z*b3*eta*u2 - aprm_s2z*bb3*eta*u2 + 2*aprm_s2z
BRprm_s2z = invsqrtdeltaT*(-deltaT*invsqrtdeltaRprm_s2z + deltaTUSCORErprm_s2z/2 - deltaTprm_s2z*invsqrtdeltaR) + invsqrtdeltaTprm_s2z*(-deltaT*invsqrtdeltaR + deltaTUSCOREr/2)
wrprm_s2z = invLambsq*(Lamb*wwUSCORErprm_s2z - LambUSCOREr*wwprm_s2z - LambUSCORErprm_s2z*ww + Lambprm_s2z*wwUSCOREr) + invLambsqprm_s2z*(Lamb*wwUSCOREr - LambUSCOREr*ww)
nurpt2prm_s2z = w2*(deltaTUSCOREr*w2prm_s2z + deltaTUSCORErprm_s2z*w2 - 4.0*deltaTprm_s2z*r) + w2prm_s2z*(-4.0*deltaT*r + deltaTUSCOREr*w2)
nurpt1prm_s2z = invdeltaT*nurpt2prm_s2z + invdeltaTprm_s2z*nurpt2
nurprm_s2z = invLamb*nurpt1prm_s2z/2 + invLambprm_s2z*nurpt1/2 + invrho2prm_s2z*r
murprm_s2z = invrho2prm_s2z*r - invsqrtdeltaRprm_s2z
a2costhetaprm_s2z = a2*costhetaprm_s2z + a2prm_s2z*costheta
wcospt2prm_s2z = deltaT*wwprm_s2z + deltaTprm_s2z*ww
wcospt1prm_s2z = invLambsq*wcospt2prm_s2z + invLambsqprm_s2z*wcospt2
wcosprm_s2z = -2*a2costheta*wcospt1prm_s2z - 2*a2costhetaprm_s2z*wcospt1
nucospt3prm_s2z = invLamb*invrho2prm_s2z + invLambprm_s2z*invrho2
nucospt2prm_s2z = nucospt3*w2prm_s2z + nucospt3prm_s2z*w2
nucospt1prm_s2z = a2costheta*nucospt2prm_s2z + a2costhetaprm_s2z*nucospt2
nucosprm_s2z = nucospt1*(-deltaTprm_s2z + w2prm_s2z) + nucospt1prm_s2z*(-deltaT + w2)
mucosprm_s2z = a2costheta*invrho2prm_s2z + a2costhetaprm_s2z*invrho2
csiprm_s2z = (deltaR*deltaTprm_s2z + deltaRprm_s2z*deltaT)*sp.sign(deltaR*deltaT)/(2*w2*sp.sqrt(sp.Abs(deltaR*deltaT))) - w2prm_s2z*sp.sqrt(sp.Abs(deltaR*deltaT))/w2**2
csi1prm_s2z = csiprm_s2z*(1 - sp.Abs(tortoise - 1))
csi2prm_s2z = csiprm_s2z*(1/2 - 0.5*sp.sign(1.5 - tortoise))
prTprm_s2z = csi2prm_s2z*(nx*px + ny*py + nz*pz)
prTtimesoneminuscsi1invprm_s2z = prTprm_s2z*(1 - 1/csi1) + csi1prm_s2z*prT/csi1**2
tmppxprm_s2z = -nx*prTtimesoneminuscsi1invprm_s2z
tmppyprm_s2z = -ny*prTtimesoneminuscsi1invprm_s2z
tmppzprm_s2z = -nz*prTtimesoneminuscsi1invprm_s2z
pxirprm_s2z = r*(tmppx*xiUSCORExprm_s2z + tmppxprm_s2z*xiUSCOREx + tmppy*xiUSCOREyprm_s2z + tmppyprm_s2z*xiUSCOREy + tmppz*xiUSCOREzprm_s2z + tmppzprm_s2z*xiUSCOREz)
pvrprm_s2z = r*(tmppx*vxprm_s2z + tmppxprm_s2z*vx + tmppy*vyprm_s2z + tmppyprm_s2z*vy + tmppz*vzprm_s2z + tmppzprm_s2z*vz)
pvrsqprm_s2z = 2*pvr*pvrprm_s2z
pnprm_s2z = nx*tmppxprm_s2z + ny*tmppyprm_s2z + nz*tmppzprm_s2z
pnsqprm_s2z = 2*pn*pnprm_s2z
prprm_s2z = pnprm_s2z
prsqprm_s2z = 2*pr*prprm_s2z
pfprm_s2z = pxirprm_s2z
pxirsqprm_s2z = 2*pxir*pxirprm_s2z
ptheta2prm_s2z = invxi2*pvrsqprm_s2z + invxi2prm_s2z*pvrsq
prT4prm_s2z = 4*prT**3*prTprm_s2z
Hnspt7prm_s2z = deltaR*invrho2prm_s2z + deltaRprm_s2z*invrho2
Hnspt6prm_s2z = invxi2*rho2invLambprm_s2z + invxi2prm_s2z*rho2invLamb
Hnspt4prm_s2z = Hnspt5*prT4prm_s2z + 2*Hnspt6*pf*pfprm_s2z + Hnspt6prm_s2z*pf**2 + Hnspt7*prsqprm_s2z + Hnspt7prm_s2z*prsq + invrho2*ptheta2prm_s2z + invrho2prm_s2z*ptheta2
Hnspt3prm_s2z = Hnspt4*deltaTprm_s2z + Hnspt4prm_s2z*deltaT
Hnspt2prm_s2z = Hnspt3*rho2prm_s2z + Hnspt3prm_s2z*rho2
Hnspt1prm_s2z = pf*wwprm_s2z + pfprm_s2z*ww
Hnsprm_s2z = Hnspt1*invLambprm_s2z + Hnspt1prm_s2z*invLamb + sp.sqrt(Hnspt2*invLamb)*(Hnspt2*invLambprm_s2z/2 + Hnspt2prm_s2z*invLamb/2)/(Hnspt2*invLamb)
Qpt3prm_s2z = deltaR*invrho2prm_s2z + deltaRprm_s2z*invrho2
Qpt2prm_s2z = invxi2*rho2invLambprm_s2z + invxi2prm_s2z*rho2invLamb
Qpt1prm_s2z = invrho2*invxi2prm_s2z + invrho2prm_s2z*invxi2
Qprm_s2z = Qpt1*pvrsqprm_s2z + Qpt1prm_s2z*pvrsq + Qpt2*pxirsqprm_s2z + Qpt2prm_s2z*pxirsq + Qpt3*pnsqprm_s2z + Qpt3prm_s2z*pnsq
pn2prm_s2z = deltaR*invrho2*prsqprm_s2z + deltaR*invrho2prm_s2z*prsq + deltaRprm_s2z*invrho2*prsq
ppprm_s2z = Qprm_s2z
sKerrmultfactprm_s2z = r*(-36*pn2prm_s2z + 3*ppprm_s2z)
sStarmultfactprm_s2z = r*(-30*pn2prm_s2z + 4*ppprm_s2z)
deltaSigmaStarUSCOREx1prm_s2z = etaover12r*(sKerrUSCOREx*sKerrmultfactprm_s2z + sStarUSCOREx*sStarmultfactprm_s2z)
deltaSigmaStarUSCOREy1prm_s2z = etaover12r*(sKerrUSCOREy*sKerrmultfactprm_s2z + sStarUSCOREy*sStarmultfactprm_s2z)
deltaSigmaStarUSCOREz1prm_s2z = etaover12r*(sKerrUSCOREz*sKerrmultfactprm_s2z + sKerrUSCOREzprm_s2z*sKerrmultfact + sStarUSCOREz*sStarmultfactprm_s2z + sStarUSCOREzprm_s2z*sStarmultfact)
pn2ppprm_s2z = pn2*ppprm_s2z + pn2prm_s2z*pp
pp2prm_s2z = 2*pp*ppprm_s2z
pn2u2prm_s2z = pn2prm_s2z*u2
ppu2prm_s2z = ppprm_s2z*u2
pn2ppu2prm_s2z = pn2ppprm_s2z*u2
sMultiplier1pt6prm_s2z = -720*pn2*pn2prm_s2z + 126*pn2ppprm_s2z + 3*pp2prm_s2z
sMultiplier1pt5prm_s2z = -96*pn2ppprm_s2z + 23*pp2prm_s2z
sMultiplier1pt4prm_s2z = 324*pn2prm_s2z - 120*ppprm_s2z + r*sMultiplier1pt6prm_s2z
sMultiplier1pt3prm_s2z = -282*pn2prm_s2z + 206*ppprm_s2z + r*sMultiplier1pt5prm_s2z
sMultiplier1pt2prm_s2z = r*sMultiplier1pt4prm_s2z
sMultiplier1pt1prm_s2z = eta*sMultiplier1pt2prm_s2z + r*sMultiplier1pt3prm_s2z
sMultiplier1prm_s2z = -eta*sMultiplier1pt1prm_s2z*u2/72
sMultiplier2pt6prm_s2z = 45*pn2*pn2u2prm_s2z/8 - 13*pn2ppu2prm_s2z/8 + 45*pn2prm_s2z*pn2u2/8
sMultiplier2pt5prm_s2z = pn2ppu2prm_s2z/4 - 5*pp2prm_s2z*u2/16
sMultiplier2pt4prm_s2z = -49*pn2u2prm_s2z/8 + 17*ppu2prm_s2z/12 + r*sMultiplier2pt6prm_s2z
sMultiplier2pt3prm_s2z = -2*pn2u2prm_s2z/3 - 109*ppu2prm_s2z/36 + r*sMultiplier2pt5prm_s2z
sMultiplier2pt2prm_s2z = r*sMultiplier2pt4prm_s2z
sMultiplier2pt1prm_s2z = eta*sMultiplier2pt2prm_s2z + r*sMultiplier2pt3prm_s2z
sMultiplier2prm_s2z = eta*sMultiplier2pt1prm_s2z
deltaSigmaStarUSCOREx2prm_s2z = deltaSigmaStarUSCOREx1prm_s2z + sMultiplier1prm_s2z*sigmaStar0 + sMultiplier2prm_s2z*sigmaKerr0
deltaSigmaStarUSCOREy2prm_s2z = deltaSigmaStarUSCOREy1prm_s2z + sMultiplier1prm_s2z*sigmaStar1 + sMultiplier2prm_s2z*sigmaKerr1
deltaSigmaStarUSCOREz2prm_s2z = deltaSigmaStarUSCOREz1prm_s2z + sMultiplier1*sigmaStar2prm_s2z + sMultiplier1prm_s2z*sigmaStar2 + sMultiplier2*sigmaKerr2prm_s2z + sMultiplier2prm_s2z*sigmaKerr2
deltaSigmaStarUSCORExprm_s2z = deltaSigmaStarUSCOREx2prm_s2z
deltaSigmaStarUSCOREyprm_s2z = deltaSigmaStarUSCOREy2prm_s2z
deltaSigmaStarUSCOREzprm_s2z = d1v2*etau3*sigmaKerr2prm_s2z + deltaSigmaStarUSCOREz2prm_s2z
sxprm_s2z = deltaSigmaStarUSCORExprm_s2z
syprm_s2z = deltaSigmaStarUSCOREyprm_s2z
szprm_s2z = deltaSigmaStarUSCOREzprm_s2z + sStarUSCOREzprm_s2z
sxiprm_s2z = sx*xiUSCORExprm_s2z + sxprm_s2z*xiUSCOREx + sy*xiUSCOREyprm_s2z + syprm_s2z*xiUSCOREy + sz*xiUSCOREzprm_s2z + szprm_s2z*xiUSCOREz
svprm_s2z = sx*vxprm_s2z + sxprm_s2z*vx + sy*vyprm_s2z + syprm_s2z*vy + sz*vzprm_s2z + szprm_s2z*vz
snprm_s2z = nx*sxprm_s2z + ny*syprm_s2z + nz*szprm_s2z
s3prm_s2z = e3USCOREx*sxprm_s2z + e3USCORExprm_s2z*sx + e3USCOREy*syprm_s2z + e3USCOREyprm_s2z*sy + e3USCOREz*szprm_s2z + e3USCOREzprm_s2z*sz
sqrtQprm_s2z = Qprm_s2z/(2*sp.sqrt(Q))
oneplus2sqrtQprm_s2z = 2*sqrtQprm_s2z
oneplus1sqrtQprm_s2z = oneplus2sqrtQprm_s2z - sqrtQprm_s2z
twoB1psqrtQsqrtQprm_s2z = 2*B*oneplus1sqrtQ*sqrtQprm_s2z + 2*B*oneplus1sqrtQprm_s2z*sqrtQ + 2*Bprm_s2z*oneplus1sqrtQ*sqrtQ
invtwoB1psqrtQsqrtQprm_s2z = -twoB1psqrtQsqrtQprm_s2z/twoB1psqrtQsqrtQ**2
expMUsqsqrtQplusQprm_s2z = expMUsq*(Qprm_s2z + sqrtQprm_s2z) + expMUsqprm_s2z*(Q + sqrtQ)
Hwrpt4aprm_s2z = pxirsq*svprm_s2z + pxirsqprm_s2z*sv
Hwrpt4prm_s2z = Hwrpt4a*expMUsqexpnusqprm_s2z + Hwrpt4aprm_s2z*expMUsqexpnusq
Hwrpt3cprm_s2z = pxir*sxiprm_s2z + pxirprm_s2z*sxi
Hwrpt3bprm_s2z = Hwrpt3c*pvrprm_s2z + Hwrpt3cprm_s2z*pvr
Hwrpt3aprm_s2z = Hwrpt3b*expMUexpnuprm_s2z + Hwrpt3bprm_s2z*expMUexpnu
Hwrpt3prm_s2z = B*Hwrpt3aprm_s2z + Bprm_s2z*Hwrpt3a
Hwrpt2gprm_s2z = deltaR*svprm_s2z + deltaRprm_s2z*sv
Hwrpt2fprm_s2z = sn*sqrtdeltaRprm_s2z + snprm_s2z*sqrtdeltaR
Hwrpt2eprm_s2z = Hwrpt2f*pvrprm_s2z + Hwrpt2fprm_s2z*pvr
Hwrpt2dprm_s2z = Hwrpt2g*pnsqprm_s2z + Hwrpt2gprm_s2z*pnsq
Hwrpt2cprm_s2z = Hwrpt2e*pnprm_s2z + Hwrpt2eprm_s2z*pn
Hwrpt2bprm_s2z = expMUsqsqrtQplusQ*svprm_s2z + expMUsqsqrtQplusQprm_s2z*sv
Hwrpt2aprm_s2z = xi2*(Hwrpt2bprm_s2z + Hwrpt2cprm_s2z - Hwrpt2dprm_s2z) + xi2prm_s2z*(Hwrpt2b + Hwrpt2c - Hwrpt2d)
Hwrpt2prm_s2z = Hwrpt2a*deltaTprm_s2z + Hwrpt2aprm_s2z*deltaT
Hwrpt1bprm_s2z = invtwoB1psqrtQsqrtQ*invxi2prm_s2z + invtwoB1psqrtQsqrtQprm_s2z*invxi2
Hwrpt1aprm_s2z = Hwrpt1b*sqrtdeltaRprm_s2z + Hwrpt1bprm_s2z*sqrtdeltaR
Hwrpt1prm_s2z = Hwrpt1a*invexpMUcubinvexpnuprm_s2z + Hwrpt1aprm_s2z*invexpMUcubinvexpnu
Hwrprm_s2z = Hwrpt1*(Hwrpt2prm_s2z - Hwrpt3prm_s2z + Hwrpt4prm_s2z) + Hwrpt1prm_s2z*(Hwrpt2 - Hwrpt3 + Hwrpt4)
Hwcospt9prm_s2z = pxir*sxiprm_s2z + pxirprm_s2z*sxi
Hwcospt8prm_s2z = pvr*svprm_s2z + pvrprm_s2z*sv
Hwcospt7prm_s2z = B*Hwcospt8prm_s2z + Bprm_s2z*Hwcospt8 - Hwcospt9*expMUexpnuprm_s2z - Hwcospt9prm_s2z*expMUexpnu
Hwcospt6prm_s2z = Hwcospt7*sqrtdeltaRprm_s2z + Hwcospt7prm_s2z*sqrtdeltaR
Hwcospt5prm_s2z = -expMUsqsqrtQplusQ*xi2prm_s2z - expMUsqsqrtQplusQprm_s2z*xi2 + pvrsqprm_s2z
Hwcospt4prm_s2z = Hwcospt6*pnprm_s2z + Hwcospt6prm_s2z*pn
Hwcospt3prm_s2z = Hwcospt5*deltaTprm_s2z + Hwcospt5prm_s2z*deltaT - expMUsqexpnusq*pxirsqprm_s2z - expMUsqexpnusqprm_s2z*pxirsq
Hwcospt2prm_s2z = -B*Hwcospt4prm_s2z - Bprm_s2z*Hwcospt4 + Hwcospt3*snprm_s2z + Hwcospt3prm_s2z*sn
Hwcospt1prm_s2z = Hwcospt2*invexpMUcubinvexpnuprm_s2z + Hwcospt2prm_s2z*invexpMUcubinvexpnu
Hwcosprm_s2z = Hwcospt1*invtwoB1psqrtQsqrtQprm_s2z + Hwcospt1prm_s2z*invtwoB1psqrtQsqrtQ
deltaTsqrtQprm_s2z = deltaT*sqrtQprm_s2z + deltaTprm_s2z*sqrtQ
invdeltatTsqrtQprm_s2z = -deltaTsqrtQprm_s2z/deltaTsqrtQ**2
HSOLpt5prm_s2z = pxir*(-Bprm_s2z + expMUexpnuprm_s2z) + pxirprm_s2z*(-B + expMUexpnu)
HSOLpt4prm_s2z = HSOLpt5*invexpMUprm_s2z + HSOLpt5prm_s2z*invexpMU
HSOLpt3prm_s2z = HSOLpt4*expnusqprm_s2z + HSOLpt4prm_s2z*expnusq
HSOLpt2prm_s2z = HSOLpt3*s3prm_s2z + HSOLpt3prm_s2z*s3
HSOLpt1prm_s2z = HSOLpt2*invxi2prm_s2z + HSOLpt2prm_s2z*invxi2
HSOLprm_s2z = HSOLpt1*invdeltatTsqrtQprm_s2z + HSOLpt1prm_s2z*invdeltatTsqrtQ
deltaTsqrtQplusQprm_s2z = deltaT*(Qprm_s2z + sqrtQprm_s2z) + deltaTprm_s2z*(Q + sqrtQ)
invdeltaTsqrtQplusQprm_s2z = -deltaTsqrtQplusQprm_s2z/deltaTsqrtQplusQ**2
HSONLmult2prm_s2z = invdeltaTsqrtQplusQ*invxi2prm_s2z + invdeltaTsqrtQplusQprm_s2z*invxi2
HSONLmultprm_s2z = HSONLmult2*expnuinvexpMU2prm_s2z + HSONLmult2prm_s2z*expnuinvexpMU2
HSONLpt1bprm_s2z = pn*xi2prm_s2z + pnprm_s2z*xi2
HSONLpt1aprm_s2z = HSONLpt1b*(-mucosprm_s2z + nucosprm_s2z) + HSONLpt1bprm_s2z*(-mucos + nucos) + mur*pvrprm_s2z + murprm_s2z*pvr - nur*pvrprm_s2z - nurprm_s2z*pvr
HSONLpt1prm_s2z = HSONLpt1a*sqrtQprm_s2z + HSONLpt1aprm_s2z*sqrtQ - HSONLpt1b*mucosprm_s2z - HSONLpt1bprm_s2z*mucos + mur*pvrprm_s2z + murprm_s2z*pvr
HSONLpt2dprm_s2z = nur*pxirprm_s2z + nurprm_s2z*pxir
HSONLpt2cprm_s2z = HSONLpt2d*oneplus2sqrtQprm_s2z + HSONLpt2dprm_s2z*oneplus2sqrtQ
HSONLpt2bprm_s2z = B*sxiprm_s2z + Bprm_s2z*sxi
HSONLpt2aprm_s2z = HSONLpt2c*expMUexpnuprm_s2z + HSONLpt2cprm_s2z*expMUexpnu
HSONLpt2prm_s2z = HSONLpt1*HSONLpt2bprm_s2z + HSONLpt1prm_s2z*HSONLpt2b + HSONLpt2a*svprm_s2z + HSONLpt2aprm_s2z*sv
HSONLpt3cprm_s2z = pxir*svprm_s2z + pxirprm_s2z*sv
HSONLpt3bprm_s2z = HSONLpt3c*oneplus1sqrtQprm_s2z + HSONLpt3cprm_s2z*oneplus1sqrtQ
HSONLpt3aprm_s2z = HSONLpt3b*expMUexpnuprm_s2z + HSONLpt3bprm_s2z*expMUexpnu
HSONLpt3prm_s2z = B*HSONLpt2prm_s2z - BR*HSONLpt3aprm_s2z - BRprm_s2z*HSONLpt3a + Bprm_s2z*HSONLpt2
HSONLpt4eprm_s2z = sn*xi2prm_s2z + snprm_s2z*xi2
HSONLpt4dprm_s2z = HSONLpt4e*oneplus2sqrtQprm_s2z + HSONLpt4eprm_s2z*oneplus2sqrtQ
HSONLpt4cprm_s2z = HSONLpt4d*pxirprm_s2z + HSONLpt4dprm_s2z*pxir
HSONLpt4bprm_s2z = HSONLpt4c*nucosprm_s2z + HSONLpt4cprm_s2z*nucos
HSONLpt4aprm_s2z = HSONLpt4b*expMUexpnuprm_s2z + HSONLpt4bprm_s2z*expMUexpnu
HSONLpt4prm_s2z = -B*HSONLpt4aprm_s2z - Bprm_s2z*HSONLpt4a + HSONLpt3*sqrtdeltaRprm_s2z + HSONLpt3prm_s2z*sqrtdeltaR
HSONLprm_s2z = HSONLmult*HSONLpt4prm_s2z + HSONLmultprm_s2z*HSONLpt4
Hsprm_s2z = HSOLprm_s2z + HSONLprm_s2z + Hwcos*wcosprm_s2z + Hwcosprm_s2z*wcos + Hwr*wrprm_s2z + Hwrprm_s2z*wr + s3*wprm_s2z + s3prm_s2z*w
Hsspt1prm_s2z = 3*sn*snprm_s2z - sx*sxprm_s2z - sy*syprm_s2z - sz*szprm_s2z
Hssprm_s2z = Hsspt1prm_s2z*u3
sKerrdotsStarprm_s2z = sKerrUSCOREz*sStarUSCOREzprm_s2z + sKerrUSCOREzprm_s2z*sStarUSCOREz
Hpt1prm_s2z = etau4*s2dots2prm_s2z
Hprm_s2z = Hnsprm_s2z + Hpt1prm_s2z*dheffSSv2 + Hsprm_s2z + Hssprm_s2z
Hrealprm_s2z = Hprm_s2z*eta*sp.sign(H)/sp.sqrt(2*eta*(sp.Abs(H) - 1) + 1)