"""
Molecular integrals over Gaussian basis functions generated by sympleints.
See https://github.com/eljost/sympleints for more information.
sympleints version: 0.1.dev79+g63f1ef8.d20230515
symppy version: 1.10.1
sympleints was executed with the following arguments:
lmax = 3
lauxmax = 4
write = False
out_dir = devel_ints
keys = ['2c2e', '3c2e_sph']
sph = False
opt_basic = True
normalize = cgto
"""
import numpy
from pysisyphus.wavefunction.ints.boys import boys
[docs]
def int2c2e3d_00(ax, da, A, bx, db, B):
"""Cartesian (s|s) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((1, 1), dtype=float)
x0 = ax + bx
# 1 item(s)
result[0, 0] = numpy.sum(
34.98683665524972
* da
* db
* x0 ** (-0.5)
* boys(
0,
ax * bx * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2) / x0,
)
/ (ax * bx)
)
return result
[docs]
def int2c2e3d_01(ax, da, A, bx, db, B):
"""Cartesian (s|p) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((1, 3), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = (
34.98683665524972
* da
* db
* x0 ** (-0.5)
* boys(
1,
ax * bx * x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2),
)
/ (ax * bx)
)
# 3 item(s)
result[0, 0] = numpy.sum(-x2 * (-x1 * (ax * A[0] + bx * B[0]) + B[0]))
result[0, 1] = numpy.sum(-x2 * (-x1 * (ax * A[1] + bx * B[1]) + B[1]))
result[0, 2] = numpy.sum(-x2 * (-x1 * (ax * A[2] + bx * B[2]) + B[2]))
return result
[docs]
def int2c2e3d_02(ax, da, A, bx, db, B):
"""Cartesian (s|d) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((1, 6), dtype=float)
x0 = bx ** (-1.0)
x1 = ax + bx
x2 = x1 ** (-1.0)
x3 = ax * bx * x2 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x4 = ax ** (-1.0)
x5 = x0 * (x2 * boys(1, x3) - x4 * boys(0, x3))
x6 = -x2 * (ax * A[0] + bx * B[0]) + B[0]
x7 = 2.0 * x4 * boys(2, x3)
x8 = 17.49341832762486 * da * db * x0 * x1 ** (-0.5)
x9 = 0.5773502691896258 * x8
x10 = -x2 * (ax * A[1] + bx * B[1]) + B[1]
x11 = x6 * x7 * x8
x12 = -x2 * (ax * A[2] + bx * B[2]) + B[2]
# 6 item(s)
result[0, 0] = numpy.sum(x9 * (-x5 + x6**2 * x7))
result[0, 1] = numpy.sum(x10 * x11)
result[0, 2] = numpy.sum(x11 * x12)
result[0, 3] = numpy.sum(x9 * (x10**2 * x7 - x5))
result[0, 4] = numpy.sum(x10 * x12 * x7 * x8)
result[0, 5] = numpy.sum(x9 * (x12**2 * x7 - x5))
return result
[docs]
def int2c2e3d_03(ax, da, A, bx, db, B):
"""Cartesian (s|f) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((1, 10), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0]) + B[0]
x3 = bx ** (-1.0)
x4 = ax * bx * x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x5 = ax ** (-1.0)
x6 = x3 * (x1 * boys(2, x4) - x5 * boys(1, x4))
x7 = x2**2
x8 = boys(3, x4)
x9 = 17.49341832762486 * da * db * x0 ** (-0.5) * x3
x10 = 0.2581988897471611 * x9
x11 = -x1 * (ax * A[1] + bx * B[1]) + B[1]
x12 = -x11 * x6
x13 = 2.0 * x5 * x8
x14 = x13 * x7
x15 = 0.5773502691896258 * x9
x16 = -x1 * (ax * A[2] + bx * B[2]) + B[2]
x17 = -x16 * x6
x18 = x11**2 * x13
x19 = -x18 + x6
x20 = x15 * x2
x21 = -x13 * x16**2 + x6
# 10 item(s)
result[0, 0] = numpy.sum(x10 * x2 * (-2.0 * x5 * x7 * x8 + 3.0 * x6))
result[0, 1] = numpy.sum(-x15 * (x11 * x14 + x12))
result[0, 2] = numpy.sum(-x15 * (x14 * x16 + x17))
result[0, 3] = numpy.sum(x19 * x20)
result[0, 4] = numpy.sum(-x11 * x13 * x16 * x2 * x9)
result[0, 5] = numpy.sum(x20 * x21)
result[0, 6] = numpy.sum(x10 * (x11 * x19 - 2.0 * x12))
result[0, 7] = numpy.sum(-x15 * (x16 * x18 + x17))
result[0, 8] = numpy.sum(x11 * x15 * x21)
result[0, 9] = numpy.sum(x10 * (x16 * x21 - 2.0 * x17))
return result
[docs]
def int2c2e3d_04(ax, da, A, bx, db, B):
"""Cartesian (s|g) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((1, 15), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = x1 * (ax * A[0] + bx * B[0]) - B[0]
x3 = bx ** (-1.0)
x4 = ax * x1
x5 = bx * x4 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x6 = boys(3, x5)
x7 = 17.49341832762486
x8 = 2.0 * x3 * x7
x9 = x0 ** (-1.5) * x8
x10 = x6 * x9
x11 = x10 * x2
x12 = ax ** (-1.0)
x13 = x0 ** (-0.5)
x14 = boys(2, x5)
x15 = 0.5 * x3
x16 = x15 * (-x10 + 2.0 * x12 * x13 * x14 * x3 * x7)
x17 = boys(4, x5)
x18 = x2**2
x19 = x12 * x13 * x8
x20 = x18 * x19
x21 = x17 * x20
x22 = boys(1, x5)
x23 = x15 * (2.0 * x12 * x13 * x3 * x7 * boys(0, x5) - x22 * x9)
x24 = x15 * (2.0 * x12 * x13 * x22 * x3 * x7 - x14 * x9)
x25 = x14 * x19
x26 = 1.5 * x3
x27 = da * db
x28 = 0.09759000729485332 * x27
x29 = x1 * (ax * A[1] + bx * B[1]) - B[1]
x30 = x10 * x29
x31 = x3 * (2.0 * x12 * x13 * x14 * x29 * x3 * x7 - x30)
x32 = x21 * x29
x33 = 0.2581988897471611 * x27
x34 = x1 * (ax * A[2] + bx * B[2]) - B[2]
x35 = x3 * x34 * (-x10 + 2.0 * x12 * x13 * x14 * x3 * x7)
x36 = 0.5 * x35
x37 = x29**2
x38 = x19 * x37
x39 = x17 * x38
x40 = x16 + x39
x41 = x23 + x25 * x37 - x4 * (x24 + x38 * x6)
x42 = 0.3333333333333333 * x27
x43 = x3 * x34 * (2.0 * x12 * x13 * x14 * x29 * x3 * x7 - x30)
x44 = 1.732050807568877 * x42
x45 = x34**2
x46 = x19 * x45
x47 = x16 + x17 * x46
x48 = x23 + x25 * x45 - x4 * (x24 + x46 * x6)
x49 = x15 * x48
x50 = x29 * x40 + x31
x51 = x2 * x33
x52 = x34 * x39 + x36
x53 = x2 * x44
x54 = x34 * x47 + x35
# 15 item(s)
result[0, 0] = numpy.sum(
x28
* (
x2 * (x2 * (x16 + x21) - x3 * (x11 - 2.0 * x12 * x13 * x14 * x2 * x3 * x7))
+ x26 * (x18 * x25 + x23 - x4 * (x20 * x6 + x24))
)
)
result[0, 1] = numpy.sum(
0.5
* x33
* (
x2 * (x31 + 2.0 * x32)
- 2.0 * x29 * x3 * (x11 - 2.0 * x12 * x13 * x14 * x2 * x3 * x7)
)
)
result[0, 2] = numpy.sum(
x33
* (
x2 * (x21 * x34 + x36)
- x3 * x34 * (x11 - 2.0 * x12 * x13 * x14 * x2 * x3 * x7)
)
)
result[0, 3] = numpy.sum(x42 * (x15 * x41 + x18 * x40))
result[0, 4] = numpy.sum(0.5 * x44 * (2.0 * x32 * x34 + x43))
result[0, 5] = numpy.sum(x42 * (x18 * x47 + x49))
result[0, 6] = numpy.sum(x50 * x51)
result[0, 7] = numpy.sum(x52 * x53)
result[0, 8] = numpy.sum(x29 * x47 * x53)
result[0, 9] = numpy.sum(x51 * x54)
result[0, 10] = numpy.sum(x28 * (x26 * x41 + x29 * x50))
result[0, 11] = numpy.sum(x33 * (x29 * x52 + x43))
result[0, 12] = numpy.sum(x42 * (x37 * x47 + x49))
result[0, 13] = numpy.sum(x29 * x33 * x54)
result[0, 14] = numpy.sum(x28 * (x26 * x48 + x34 * x54))
return result
[docs]
def int2c2e3d_10(ax, da, A, bx, db, B):
"""Cartesian (p|s) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((3, 1), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = (
34.98683665524972
* da
* db
* x0 ** (-0.5)
* boys(
1,
ax * bx * x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2),
)
/ (ax * bx)
)
# 3 item(s)
result[0, 0] = numpy.sum(-x2 * (-x1 * (ax * A[0] + bx * B[0]) + A[0]))
result[1, 0] = numpy.sum(-x2 * (-x1 * (ax * A[1] + bx * B[1]) + A[1]))
result[2, 0] = numpy.sum(-x2 * (-x1 * (ax * A[2] + bx * B[2]) + A[2]))
return result
[docs]
def int2c2e3d_11(ax, da, A, bx, db, B):
"""Cartesian (p|p) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((3, 3), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = ax * bx * x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x3 = x1 * boys(1, x2)
x4 = -x1 * (ax * A[0] + bx * B[0])
x5 = x4 + B[0]
x6 = 2.0 * boys(2, x2)
x7 = x6 * (x4 + A[0])
x8 = 17.49341832762486 * da * db * x0 ** (-0.5) / (ax * bx)
x9 = -x1 * (ax * A[1] + bx * B[1])
x10 = x9 + B[1]
x11 = x7 * x8
x12 = -x1 * (ax * A[2] + bx * B[2])
x13 = x12 + B[2]
x14 = x6 * (x9 + A[1])
x15 = x14 * x8
x16 = x6 * (x12 + A[2])
x17 = x16 * x8
# 9 item(s)
result[0, 0] = numpy.sum(x8 * (x3 + x5 * x7))
result[0, 1] = numpy.sum(x10 * x11)
result[0, 2] = numpy.sum(x11 * x13)
result[1, 0] = numpy.sum(x15 * x5)
result[1, 1] = numpy.sum(x8 * (x10 * x14 + x3))
result[1, 2] = numpy.sum(x13 * x15)
result[2, 0] = numpy.sum(x17 * x5)
result[2, 1] = numpy.sum(x10 * x17)
result[2, 2] = numpy.sum(x8 * (x13 * x16 + x3))
return result
[docs]
def int2c2e3d_12(ax, da, A, bx, db, B):
"""Cartesian (p|d) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((3, 6), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = x2 + A[0]
x4 = bx ** (-1.0)
x5 = ax * bx * x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x6 = x1 * boys(2, x5)
x7 = ax ** (-1.0)
x8 = x4 * (x6 - x7 * boys(1, x5))
x9 = x2 + B[0]
x10 = boys(3, x5)
x11 = -2.0 * x10 * x7 * x9**2 + x8
x12 = x7 * x9
x13 = 2.0 * x6
x14 = 17.49341832762486 * da * db * x0 ** (-0.5) * x4
x15 = 0.5773502691896258 * x14
x16 = -x1 * (ax * A[1] + bx * B[1])
x17 = x16 + B[1]
x18 = 2.0 * x10
x19 = x14 * x7
x20 = x19 * (x18 * x3 * x9 + x6)
x21 = -x1 * (ax * A[2] + bx * B[2])
x22 = x21 + B[2]
x23 = x18 * x7
x24 = -(x17**2) * x23 + x8
x25 = x15 * x3
x26 = x14 * x22 * x23
x27 = -(x22**2) * x23 + x8
x28 = x16 + A[1]
x29 = x15 * x28
x30 = x17 * x18 * x28 + x6
x31 = x12 * x14
x32 = x13 * x7
x33 = x21 + A[2]
x34 = x15 * x33
x35 = x18 * x22 * x33 + x6
# 18 item(s)
result[0, 0] = numpy.sum(x15 * (x11 * x3 - x12 * x13))
result[0, 1] = numpy.sum(-x17 * x20)
result[0, 2] = numpy.sum(-x20 * x22)
result[0, 3] = numpy.sum(x24 * x25)
result[0, 4] = numpy.sum(-x17 * x26 * x3)
result[0, 5] = numpy.sum(x25 * x27)
result[1, 0] = numpy.sum(x11 * x29)
result[1, 1] = numpy.sum(-x30 * x31)
result[1, 2] = numpy.sum(-x26 * x28 * x9)
result[1, 3] = numpy.sum(x15 * (-x17 * x32 + x24 * x28))
result[1, 4] = numpy.sum(-x19 * x22 * x30)
result[1, 5] = numpy.sum(x27 * x29)
result[2, 0] = numpy.sum(x11 * x34)
result[2, 1] = numpy.sum(-x14 * x17 * x23 * x33 * x9)
result[2, 2] = numpy.sum(-x31 * x35)
result[2, 3] = numpy.sum(x24 * x34)
result[2, 4] = numpy.sum(-x17 * x19 * x35)
result[2, 5] = numpy.sum(x15 * (-x22 * x32 + x27 * x33))
return result
[docs]
def int2c2e3d_13(ax, da, A, bx, db, B):
"""Cartesian (p|f) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((3, 10), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = x2 + A[0]
x4 = x2 + B[0]
x5 = bx ** (-1.0)
x6 = ax * bx * x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x7 = boys(3, x6)
x8 = x1 * x7
x9 = ax ** (-1.0)
x10 = boys(2, x6)
x11 = x5 * (-x10 * x9 + x8)
x12 = x4**2
x13 = boys(4, x6)
x14 = x4 * (-3.0 * x11 + 2.0 * x12 * x13 * x9)
x15 = x5 * (x1 * x10 - x9 * boys(1, x6))
x16 = x1 * (2.0 * x12 * x7 * x9 - x15)
x17 = 17.49341832762486 * da * db * x0 ** (-0.5) * x5
x18 = 0.2581988897471611 * x17
x19 = -x1 * (ax * A[1] + bx * B[1])
x20 = x19 + B[1]
x21 = -x11 * x20
x22 = 2.0 * x9
x23 = x12 * x13 * x22
x24 = x20 * x23 + x21
x25 = x22 * x8
x26 = x20 * x25
x27 = 0.5773502691896258 * x17
x28 = -x1 * (ax * A[2] + bx * B[2])
x29 = x28 + B[2]
x30 = -x11 * x29
x31 = x23 * x29 + x30
x32 = x20**2 * x22
x33 = x15 - x32 * x7
x34 = 0.5 * x1
x35 = x13 * x32
x36 = x11 - x35
x37 = x3 * x4
x38 = 2.0 * x13
x39 = x17 * x29 * x9
x40 = x22 * x29**2
x41 = x15 - x40 * x7
x42 = x34 * x41
x43 = x11 - x13 * x40
x44 = -x20 * x36 + 2.0 * x21
x45 = x18 * x3
x46 = x29 * x35 + x30
x47 = x27 * x3
x48 = -x29 * x43 + 2.0 * x30
x49 = x19 + A[1]
x50 = x18 * x49
x51 = 0.5 * x16
x52 = x27 * x49
x53 = x27 * x4
x54 = x20 * x49
x55 = -x33
x56 = 1.5 * x1
x57 = x28 + A[2]
x58 = x18 * x57
x59 = 2.0 * x1 * x29 * x7 * x9 - x43 * x57
# 30 item(s)
result[0, 0] = numpy.sum(0.5 * x18 * (2.0 * x14 * x3 + 3.0 * x16))
result[0, 1] = numpy.sum(x27 * (x24 * x3 + x26 * x4))
result[0, 2] = numpy.sum(x27 * (x25 * x29 * x4 + x3 * x31))
result[0, 3] = numpy.sum(-x27 * (x33 * x34 + x36 * x37))
result[0, 4] = numpy.sum(x20 * x39 * (x37 * x38 + x8))
result[0, 5] = numpy.sum(-x27 * (x37 * x43 + x42))
result[0, 6] = numpy.sum(x44 * x45)
result[0, 7] = numpy.sum(x46 * x47)
result[0, 8] = numpy.sum(-x20 * x43 * x47)
result[0, 9] = numpy.sum(x45 * x48)
result[1, 0] = numpy.sum(x14 * x50)
result[1, 1] = numpy.sum(x27 * (x24 * x49 + x51))
result[1, 2] = numpy.sum(x31 * x52)
result[1, 3] = numpy.sum(x53 * (2.0 * x1 * x20 * x7 * x9 - x36 * x49))
result[1, 4] = numpy.sum(x39 * x4 * (x38 * x54 + x8))
result[1, 5] = numpy.sum(-x4 * x43 * x52)
result[1, 6] = numpy.sum(x18 * (x44 * x49 + x55 * x56))
result[1, 7] = numpy.sum(x27 * (x26 * x29 + x46 * x49))
result[1, 8] = numpy.sum(-x27 * (x42 + x43 * x54))
result[1, 9] = numpy.sum(x48 * x50)
result[2, 0] = numpy.sum(x14 * x58)
result[2, 1] = numpy.sum(x24 * x27 * x57)
result[2, 2] = numpy.sum(x27 * (x31 * x57 + x51))
result[2, 3] = numpy.sum(-x36 * x53 * x57)
result[2, 4] = numpy.sum(x17 * x20 * x4 * x9 * (x29 * x38 * x57 + x8))
result[2, 5] = numpy.sum(x53 * x59)
result[2, 6] = numpy.sum(x44 * x58)
result[2, 7] = numpy.sum(x27 * (x34 * x55 + x46 * x57))
result[2, 8] = numpy.sum(x20 * x27 * x59)
result[2, 9] = numpy.sum(x18 * (-x41 * x56 + x48 * x57))
return result
[docs]
def int2c2e3d_14(ax, da, A, bx, db, B):
"""Cartesian (p|g) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((3, 15), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - A[0]
x4 = -x2 - B[0]
x5 = bx ** (-1.0)
x6 = ax * x1
x7 = bx * x6 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x8 = boys(4, x7)
x9 = 17.49341832762486
x10 = 2.0 * x5 * x9
x11 = x0 ** (-1.5) * x10
x12 = x11 * x8
x13 = x12 * x4
x14 = ax ** (-1.0)
x15 = x0 ** (-0.5)
x16 = boys(3, x7)
x17 = 0.5 * x5
x18 = x17 * (-x12 + 2.0 * x14 * x15 * x16 * x5 * x9)
x19 = boys(5, x7)
x20 = x4**2
x21 = x14 * x15
x22 = x10 * x21
x23 = x20 * x22
x24 = x19 * x23
x25 = boys(2, x7)
x26 = x17 * (-x11 * x25 + 2.0 * x14 * x15 * x5 * x9 * boys(1, x7))
x27 = x11 * x16
x28 = x17 * (2.0 * x14 * x15 * x25 * x5 * x9 - x27)
x29 = x23 * x8
x30 = x28 + x29
x31 = x16 * x22
x32 = 1.5 * x5
x33 = x32 * (x20 * x31 + x26 - x30 * x6) + x4 * (
x4 * (x18 + x24) - x5 * (x13 - 2.0 * x14 * x15 * x16 * x4 * x5 * x9)
)
x34 = 0.5 / (ax + bx)
x35 = x34 * x4 * (x30 + x5 * (2.0 * x14 * x15 * x25 * x5 * x9 - x27))
x36 = da * db
x37 = 0.09759000729485332 * x36
x38 = -x1 * (ax * A[1] + bx * B[1])
x39 = -x38 - B[1]
x40 = x12 * x39
x41 = x5 * (2.0 * x14 * x15 * x16 * x39 * x5 * x9 - x40)
x42 = x24 * x39
x43 = -x39 * x5 * (x13 - 2.0 * x14 * x15 * x16 * x4 * x5 * x9) + 0.5 * x4 * (
x41 + 2.0 * x42
)
x44 = x39 * x5 * (2.0 * x14 * x15 * x25 * x5 * x9 - x27)
x45 = 0.5 * x34 * (2.0 * x29 * x39 + x44)
x46 = 0.2581988897471611 * x36
x47 = -x1 * (ax * A[2] + bx * B[2])
x48 = -x47 - B[2]
x49 = x48 * x5 * (-x12 + 2.0 * x14 * x15 * x16 * x5 * x9)
x50 = 0.5 * x49
x51 = x4 * (x24 * x48 + x50) - x48 * x5 * (x13 - 2.0 * x14 * x15 * x16 * x4 * x5 * x9)
x52 = x48 * x5 * (2.0 * x14 * x15 * x25 * x5 * x9 - x27)
x53 = 0.5 * x52
x54 = x34 * (x29 * x48 + x53)
x55 = x39**2
x56 = x22 * x55
x57 = x19 * x56
x58 = x18 + x57
x59 = x56 * x8
x60 = x28 + x59
x61 = x26 + x31 * x55 - x6 * x60
x62 = x17 * x61 + x20 * x58
x63 = x34 * x4
x64 = x60 * x63
x65 = 0.3333333333333333 * x36
x66 = x48 * x5 * (2.0 * x14 * x15 * x16 * x39 * x5 * x9 - x40)
x67 = x42 * x48 + 0.5 * x66
x68 = 4.0 * x21 * x39 * x48 * x5 * x63 * x8 * x9
x69 = 1.732050807568877 * x65
x70 = x48**2
x71 = x22 * x70
x72 = x18 + x19 * x71
x73 = x28 + x71 * x8
x74 = x26 + x31 * x70 - x6 * x73
x75 = x17 * x74
x76 = x20 * x72 + x75
x77 = x34 * x73
x78 = x4 * x77
x79 = x34 * (x39 * x60 + x44)
x80 = x39 * x58 + x41
x81 = x3 * x4
x82 = x34 * (x48 * x59 + x53)
x83 = x48 * x57 + x50
x84 = x39 * x77
x85 = x39 * x72
x86 = x34 * (x48 * x73 + x52)
x87 = x48 * x72 + x49
x88 = x32 * x61 + x39 * x80
x89 = x3 * x37
x90 = x39 * x83 + x66
x91 = x3 * x46
x92 = x55 * x72 + x75
x93 = x39 * x87
x94 = x32 * x74 + x48 * x87
x95 = -x38 - A[1]
x96 = x37 * x95
x97 = x4 * x95
x98 = -x47 - A[2]
x99 = x37 * x98
x100 = x4 * x98
# 45 item(s)
result[0, 0] = numpy.sum(x37 * (x3 * x33 + 4.0 * x35))
result[0, 1] = numpy.sum(x46 * (x3 * x43 + 3.0 * x45))
result[0, 2] = numpy.sum(x46 * (x3 * x51 + 3.0 * x54))
result[0, 3] = numpy.sum(x65 * (x3 * x62 + 2.0 * x64))
result[0, 4] = numpy.sum(x69 * (x3 * x67 + x68))
result[0, 5] = numpy.sum(x65 * (x3 * x76 + 2.0 * x78))
result[0, 6] = numpy.sum(x46 * (x79 + x80 * x81))
result[0, 7] = numpy.sum(x69 * (x81 * x83 + x82))
result[0, 8] = numpy.sum(x69 * (x81 * x85 + x84))
result[0, 9] = numpy.sum(x46 * (x81 * x87 + x86))
result[0, 10] = numpy.sum(x88 * x89)
result[0, 11] = numpy.sum(x90 * x91)
result[0, 12] = numpy.sum(x3 * x65 * x92)
result[0, 13] = numpy.sum(x91 * x93)
result[0, 14] = numpy.sum(x89 * x94)
result[1, 0] = numpy.sum(x33 * x96)
result[1, 1] = numpy.sum(x46 * (x35 + x43 * x95))
result[1, 2] = numpy.sum(x46 * x51 * x95)
result[1, 3] = numpy.sum(x65 * (2.0 * x45 + x62 * x95))
result[1, 4] = numpy.sum(x69 * (x54 + x67 * x95))
result[1, 5] = numpy.sum(x65 * x76 * x95)
result[1, 6] = numpy.sum(x46 * (3.0 * x64 + x80 * x97))
result[1, 7] = numpy.sum(x69 * (x68 + x83 * x97))
result[1, 8] = numpy.sum(x69 * (x78 + x85 * x97))
result[1, 9] = numpy.sum(x46 * x87 * x97)
result[1, 10] = numpy.sum(x37 * (4.0 * x79 + x88 * x95))
result[1, 11] = numpy.sum(x46 * (3.0 * x82 + x90 * x95))
result[1, 12] = numpy.sum(x65 * (2.0 * x84 + x92 * x95))
result[1, 13] = numpy.sum(x46 * (x86 + x93 * x95))
result[1, 14] = numpy.sum(x94 * x96)
result[2, 0] = numpy.sum(x33 * x99)
result[2, 1] = numpy.sum(x43 * x46 * x98)
result[2, 2] = numpy.sum(x46 * (x35 + x51 * x98))
result[2, 3] = numpy.sum(x62 * x65 * x98)
result[2, 4] = numpy.sum(x69 * (x45 + x67 * x98))
result[2, 5] = numpy.sum(x65 * (2.0 * x54 + x76 * x98))
result[2, 6] = numpy.sum(x100 * x46 * x80)
result[2, 7] = numpy.sum(x69 * (x100 * x83 + x64))
result[2, 8] = numpy.sum(x69 * (x100 * x85 + x68))
result[2, 9] = numpy.sum(x46 * (x100 * x87 + 3.0 * x78))
result[2, 10] = numpy.sum(x88 * x99)
result[2, 11] = numpy.sum(x46 * (x79 + x90 * x98))
result[2, 12] = numpy.sum(x65 * (2.0 * x82 + x92 * x98))
result[2, 13] = numpy.sum(x46 * (3.0 * x84 + x93 * x98))
result[2, 14] = numpy.sum(x37 * (4.0 * x86 + x94 * x98))
return result
[docs]
def int2c2e3d_20(ax, da, A, bx, db, B):
"""Cartesian (d|s) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((6, 1), dtype=float)
x0 = ax ** (-1.0)
x1 = ax + bx
x2 = x1 ** (-1.0)
x3 = ax * bx * x2 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x4 = bx ** (-1.0)
x5 = x0 * (-x2 * boys(1, x3) + x4 * boys(0, x3))
x6 = -x2 * (ax * A[0] + bx * B[0]) + A[0]
x7 = 2.0 * x4 * boys(2, x3)
x8 = 17.49341832762486 * da * db * x0 * x1 ** (-0.5)
x9 = 0.5773502691896258 * x8
x10 = -x2 * (ax * A[1] + bx * B[1]) + A[1]
x11 = x6 * x7 * x8
x12 = -x2 * (ax * A[2] + bx * B[2]) + A[2]
# 6 item(s)
result[0, 0] = numpy.sum(x9 * (x5 + x6**2 * x7))
result[1, 0] = numpy.sum(x10 * x11)
result[2, 0] = numpy.sum(x11 * x12)
result[3, 0] = numpy.sum(x9 * (x10**2 * x7 + x5))
result[4, 0] = numpy.sum(x10 * x12 * x7 * x8)
result[5, 0] = numpy.sum(x9 * (x12**2 * x7 + x5))
return result
[docs]
def int2c2e3d_21(ax, da, A, bx, db, B):
"""Cartesian (d|p) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((6, 3), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = x2 + B[0]
x4 = ax ** (-1.0)
x5 = ax * bx * x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x6 = x1 * boys(2, x5)
x7 = bx ** (-1.0)
x8 = x4 * (x6 - x7 * boys(1, x5))
x9 = -x3 * x8
x10 = x2 + A[0]
x11 = 2.0 * boys(3, x5)
x12 = x11 * x3
x13 = x10 * x12 + x6
x14 = x10 * x7
x15 = 17.49341832762486 * da * db * x0 ** (-0.5) * x4
x16 = 0.5773502691896258 * x15
x17 = -x1 * (ax * A[1] + bx * B[1])
x18 = x17 + B[1]
x19 = -x18 * x8
x20 = x11 * x18
x21 = x10**2 * x7
x22 = -x1 * (ax * A[2] + bx * B[2])
x23 = x22 + B[2]
x24 = -x23 * x8
x25 = x11 * x23
x26 = x17 + A[1]
x27 = x26 * x7
x28 = x13 * x15
x29 = x20 * x26 + x6
x30 = x14 * x15
x31 = x22 + A[2]
x32 = x31 * x7
x33 = x25 * x31 + x6
x34 = x26**2 * x7
x35 = x15 * x27
x36 = x31**2 * x7
# 18 item(s)
result[0, 0] = numpy.sum(-x16 * (x13 * x14 + x14 * x6 + x9))
result[0, 1] = numpy.sum(-x16 * (x19 + x20 * x21))
result[0, 2] = numpy.sum(-x16 * (x21 * x25 + x24))
result[1, 0] = numpy.sum(-x27 * x28)
result[1, 1] = numpy.sum(-x29 * x30)
result[1, 2] = numpy.sum(-x25 * x26 * x30)
result[2, 0] = numpy.sum(-x28 * x32)
result[2, 1] = numpy.sum(-x20 * x30 * x31)
result[2, 2] = numpy.sum(-x30 * x33)
result[3, 0] = numpy.sum(-x16 * (x12 * x34 + x9))
result[3, 1] = numpy.sum(-x16 * (x19 + x27 * x29 + x27 * x6))
result[3, 2] = numpy.sum(-x16 * (x24 + x25 * x34))
result[4, 0] = numpy.sum(-x12 * x31 * x35)
result[4, 1] = numpy.sum(-x15 * x29 * x32)
result[4, 2] = numpy.sum(-x33 * x35)
result[5, 0] = numpy.sum(-x16 * (x12 * x36 + x9))
result[5, 1] = numpy.sum(-x16 * (x19 + x20 * x36))
result[5, 2] = numpy.sum(-x16 * (x24 + x32 * x33 + x32 * x6))
return result
[docs]
def int2c2e3d_22(ax, da, A, bx, db, B):
"""Cartesian (d|d) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((6, 6), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = ax * bx * x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x3 = boys(1, x2)
x4 = ax ** (-1.0)
x5 = (x1 * x3 - x4 * boys(0, x2)) / bx**2
x6 = bx ** (-1.0)
x7 = boys(2, x2)
x8 = x1 * x7
x9 = x6 * (-x3 * x4 + x8)
x10 = -x1 * (ax * A[0] + bx * B[0])
x11 = x10 + B[0]
x12 = x11**2
x13 = boys(3, x2)
x14 = x4 * x7
x15 = 2.0 * x14 * x6
x16 = 0.5 * x4
x17 = x16 * (x1 * (2.0 * x12 * x13 * x4 - x9) - x12 * x15 + x5)
x18 = x10 + A[0]
x19 = x1 * x13
x20 = x6 * (-x14 + x19)
x21 = boys(4, x2)
x22 = -2.0 * x12 * x21 * x4 + x20
x23 = x11 * x19
x24 = 2.0 * x4
x25 = x18 * x6
x26 = x11 * x18
x27 = 2.0 * x13
x28 = x4 * x6
x29 = x1 * x28
x30 = 17.49341832762486 * da * db * x0 ** (-0.5)
x31 = 0.3333333333333333 * x30
x32 = -x1 * (ax * A[1] + bx * B[1])
x33 = x32 + B[1]
x34 = 2.0 * x21
x35 = x19 + x26 * x34
x36 = x25 * x35
x37 = -x11
x38 = -x33
x39 = x19 - x6 * x7
x40 = -x37 * x38 * x39 * x4
x41 = x19 * x25
x42 = 1.732050807568877 * x31
x43 = x4 * x42
x44 = -x1 * (ax * A[2] + bx * B[2])
x45 = x44 + B[2]
x46 = -x45
x47 = -x37 * x39 * x4 * x46
x48 = x33**2
x49 = x16 * (x1 * (2.0 * x13 * x4 * x48 - x9) - x15 * x48 + x5)
x50 = x20 - x34 * x4 * x48
x51 = x18**2 * x6
x52 = -x38 * x39 * x4 * x46
x53 = x34 * x45
x54 = x45**2
x55 = x16 * (x1 * (2.0 * x13 * x4 * x54 - x9) - x15 * x54 + x5)
x56 = x20 - x34 * x4 * x54
x57 = x32 + A[1]
x58 = x57 * x6
x59 = x42 * (2.0 * x1 * x11 * x13 * x4 - x18 * x22)
x60 = x33 * x57
x61 = x27 * x60 + x8
x62 = 0.5 * x1
x63 = x19 + x34 * x60
x64 = x28 * x30
x65 = x45 * x58
x66 = x30 * x4
x67 = x35 * x66
x68 = x19 * x24
x69 = x33 * x68 - x50 * x57
x70 = x25 * x42
x71 = x25 * x66
x72 = x44 + A[2]
x73 = x6 * x72
x74 = x33 * x73
x75 = x45 * x72
x76 = x27 * x75 + x8
x77 = x62 * x76
x78 = x19 + x34 * x75
x79 = x45 * x68 - x56 * x72
x80 = x57**2 * x6
x81 = x58 * x63
x82 = x42 * x58
x83 = x11 * x66
x84 = x6 * x72**2
x85 = x73 * x78
# 36 item(s)
result[0, 0] = numpy.sum(
-x31 * (x17 + x25 * (x18 * x22 - x23 * x24) - x29 * (x26 * x27 + x8))
)
result[0, 1] = numpy.sum(x43 * (x33 * x36 + x33 * x41 + x40))
result[0, 2] = numpy.sum(x43 * (x36 * x45 + x41 * x45 + x47))
result[0, 3] = numpy.sum(-x31 * (x49 + x50 * x51))
result[0, 4] = numpy.sum(x43 * (x33 * x51 * x53 + x52))
result[0, 5] = numpy.sum(-x31 * (x51 * x56 + x55))
result[1, 0] = numpy.sum(x58 * x59)
result[1, 1] = numpy.sum(x64 * (x26 * x63 + x61 * x62))
result[1, 2] = numpy.sum(x65 * x67)
result[1, 3] = numpy.sum(x69 * x70)
result[1, 4] = numpy.sum(x45 * x63 * x71)
result[1, 5] = numpy.sum(-x56 * x57 * x70)
result[2, 0] = numpy.sum(x59 * x73)
result[2, 1] = numpy.sum(x67 * x74)
result[2, 2] = numpy.sum(x64 * (x26 * x78 + x77))
result[2, 3] = numpy.sum(-x50 * x70 * x72)
result[2, 4] = numpy.sum(x33 * x71 * x78)
result[2, 5] = numpy.sum(x70 * x79)
result[3, 0] = numpy.sum(-x31 * (x17 + x22 * x80))
result[3, 1] = numpy.sum(x43 * (x11 * x81 + x23 * x58 + x40))
result[3, 2] = numpy.sum(x43 * (x11 * x53 * x80 + x47))
result[3, 3] = numpy.sum(x31 * (x29 * x61 - x49 + x58 * x69))
result[3, 4] = numpy.sum(x43 * (x19 * x65 + x45 * x81 + x52))
result[3, 5] = numpy.sum(-x31 * (x55 + x56 * x80))
result[4, 0] = numpy.sum(-x22 * x72 * x82)
result[4, 1] = numpy.sum(x63 * x73 * x83)
result[4, 2] = numpy.sum(x58 * x78 * x83)
result[4, 3] = numpy.sum(x42 * x73 * (2.0 * x1 * x13 * x33 * x4 - x50 * x57))
result[4, 4] = numpy.sum(x64 * (x60 * x78 + x77))
result[4, 5] = numpy.sum(x79 * x82)
result[5, 0] = numpy.sum(-x31 * (x17 + x22 * x84))
result[5, 1] = numpy.sum(x43 * (x11 * x33 * x34 * x84 + x40))
result[5, 2] = numpy.sum(x43 * (x11 * x85 + x23 * x73 + x47))
result[5, 3] = numpy.sum(-x31 * (x49 + x50 * x84))
result[5, 4] = numpy.sum(x43 * (x19 * x74 + x33 * x85 + x52))
result[5, 5] = numpy.sum(x31 * (x29 * x76 - x55 + x73 * x79))
return result
[docs]
def int2c2e3d_23(ax, da, A, bx, db, B):
"""Cartesian (d|f) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((6, 10), dtype=float)
x0 = ax ** (-1.0)
x1 = ax + bx
x2 = x1 ** (-1.0)
x3 = -x2 * (ax * A[0] + bx * B[0])
x4 = x3 + B[0]
x5 = bx ** (-1.0)
x6 = ax * bx * x2 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x7 = boys(3, x6)
x8 = x2 * x7
x9 = boys(2, x6)
x10 = -x0 * x9 + x8
x11 = x10 * x5
x12 = x4**2
x13 = boys(4, x6)
x14 = -2.0 * x0 * x12 * x13 + x11
x15 = -x14
x16 = -x4
x17 = 2.0 * x16
x18 = -x0 * boys(1, x6) + x2 * x9
x19 = x18 * x5
x20 = x4 * x5
x21 = x18 / bx**2
x22 = x0 * (
x17 * x21 - x2 * (x11 * x17 + x15 * x4) + x20 * (2.0 * x0 * x12 * x7 - x19)
)
x23 = x3 + A[0]
x24 = x13 * x2
x25 = x0 * x7
x26 = x5 * (x24 - x25)
x27 = boys(5, x6)
x28 = x17 * x26 + x4 * (2.0 * x0 * x12 * x27 - x26)
x29 = x23 * x28
x30 = x15 * x2
x31 = x23 * x5
x32 = 2.0 * x0
x33 = x32 * x8
x34 = 3.0 * x2 * x5
x35 = 17.49341832762486 * da * db * x1 ** (-0.5)
x36 = 2.23606797749979 * x35
x37 = 0.03333333333333333 * x36
x38 = -x2 * (ax * A[1] + bx * B[1])
x39 = x38 + B[1]
x40 = -x39
x41 = x11 * x40
x42 = 2.0 * x12
x43 = x0 * x42
x44 = x13 * x43
x45 = x21 * x40
x46 = x39 * x5
x47 = x25 * x42
x48 = -x2 * (x39 * x44 + x41) + x45 + x46 * x47
x49 = 0.5 * x0
x50 = x48 * x49
x51 = x26 * x40
x52 = x27 * x43
x53 = x39 * x52 + x51
x54 = x24 * x32
x55 = x39 * x54
x56 = x23 * x53 + x4 * x55
x57 = x23 * x4
x58 = 2.0 * x13
x59 = x0 * x2
x60 = x59 * (x57 * x58 + x8)
x61 = 0.3333333333333333 * x35
x62 = -x2 * (ax * A[2] + bx * B[2])
x63 = x62 + B[2]
x64 = -x63
x65 = x11 * x64
x66 = x21 * x64
x67 = x5 * x63
x68 = -x2 * (x44 * x63 + x65) + x47 * x67 + x66
x69 = x49 * x68
x70 = x26 * x64
x71 = x52 * x63 + x70
x72 = x54 * x63
x73 = x23 * x71 + x4 * x72
x74 = -x10 * x5
x75 = x40**2
x76 = x0 * x58
x77 = -x18 * x5
x78 = 2.0 * x25
x79 = x2 * (x74 + x75 * x76) - x5 * (x75 * x78 + x77)
x80 = x0 * x16
x81 = x39**2
x82 = -2.0 * x0 * x13 * x81 + x11
x83 = -x82
x84 = x2 * x83
x85 = 2.0 * x0 * x27 * x81 - x26
x86 = x57 * x85
x87 = 0.1666666666666667 * x35
x88 = x40 * x64 * x80 * (x24 - x5 * x7)
x89 = 2.0 * x27
x90 = x39 * x63
x91 = x31 * x90
x92 = 1.732050807568877 * x61
x93 = x0 * x92
x94 = x64**2
x95 = x2 * (x74 + x76 * x94) - x5 * (x77 + x78 * x94)
x96 = x63**2
x97 = -2.0 * x0 * x13 * x96 + x11
x98 = -x97
x99 = x2 * x98
x100 = -2.0 * x0 * x27 * x96 + x26
x101 = -x100
x102 = x101 * x57
x103 = x0 * (
-x2 * (x39 * x83 + 2.0 * x41) + 2.0 * x45 + x46 * (2.0 * x0 * x7 * x81 - x19)
)
x104 = 0.5 * x103
x105 = x39 * x85 + 2.0 * x51
x106 = x23**2
x107 = x106 * x5
x108 = 0.06666666666666667 * x36
x109 = -x2 * (x63 * x76 * x81 + x65) + x66 + x67 * x78 * x81
x110 = x109 * x49
x111 = x0 * x63 * x81 * x89 + x70
x112 = x40 * x95
x113 = x112 * x49
x114 = x0 * (
-x2 * (x63 * x98 + 2.0 * x65) + 2.0 * x66 + x67 * (2.0 * x0 * x7 * x96 - x19)
)
x115 = 0.5 * x114
x116 = x101 * x63 + 2.0 * x70
x117 = x38 + A[1]
x118 = x117 * x5
x119 = 0.2581988897471611 * x35
x120 = 0.5 * x119 * (3.0 * x14 * x2 - 2.0 * x29)
x121 = x117 * x53
x122 = 2.0 * x121 + x30
x123 = 0.5 * x23
x124 = x117 * x39
x125 = x124 * x58 + x8
x126 = x4 * x59
x127 = x5 * x92
x128 = x118 * x92
x129 = x117 * x83 + x33 * x39
x130 = 0.5 * x2
x131 = x117 * x85 + x55
x132 = x124 * x89 + x24
x133 = x0 * x35
x134 = x105 * x117
x135 = x119 * x31
x136 = x111 * x117 + x54 * x90
x137 = x31 * x92
x138 = x62 + A[2]
x139 = x138 * x5
x140 = x139 * x92
x141 = x138 * x71
x142 = 2.0 * x141 + x30
x143 = x138 * x63
x144 = x143 * x58 + x8
x145 = 0.5 * x84
x146 = x130 * x144
x147 = x143 * x89 + x24
x148 = x138 * x98 + x33 * x63
x149 = x130 * x148
x150 = x101 * x138 + x72
x151 = x111 * x138
x152 = 2.0 * x0 * x13 * x2 * x63 - x100 * x138
x153 = x116 * x138
x154 = x153 + 1.5 * x99
x155 = 0.5 * x22
x156 = x117**2
x157 = x156 * x5
x158 = x16 * x49
x159 = x158 * x79
x160 = x117 * x20
x161 = x125 * x59
x162 = x160 * x63
x163 = x158 * x95
x164 = x118 * x119
x165 = x138 * x20
x166 = 2.0 * x151 + x84
x167 = x144 * x59
x168 = x138**2
x169 = x168 * x5
x170 = x165 * x39
x171 = x138 * x150
# 60 item(s)
result[0, 0] = numpy.sum(
-x37 * (x22 + x31 * (2.0 * x29 + 3.0 * x30) + x34 * (x15 * x23 + x33 * x4))
)
result[0, 1] = numpy.sum(-x61 * (x31 * x56 + x46 * x60 + x50))
result[0, 2] = numpy.sum(-x61 * (x31 * x73 + x60 * x67 + x69))
result[0, 3] = numpy.sum(-x87 * (x31 * x84 + x31 * (x84 + 2.0 * x86) + x79 * x80))
result[0, 4] = numpy.sum(-x93 * (x24 * x91 + x88 + x91 * (x24 + x57 * x89)))
result[0, 5] = numpy.sum(-x87 * (x31 * x99 + x31 * (2.0 * x102 + x99) + x80 * x95))
result[0, 6] = numpy.sum(-x108 * (x104 + x105 * x107))
result[0, 7] = numpy.sum(-x61 * (x107 * x111 + x110))
result[0, 8] = numpy.sum(-x61 * (x101 * x106 * x46 + x113))
result[0, 9] = numpy.sum(-x108 * (x107 * x116 + x115))
result[1, 0] = numpy.sum(x118 * x120)
result[1, 1] = numpy.sum(-x127 * (x122 * x123 + x125 * x126))
result[1, 2] = numpy.sum(-x128 * x73)
result[1, 3] = numpy.sum(-x127 * (x129 * x130 + x131 * x57))
result[1, 4] = numpy.sum(-x133 * x67 * (x125 * x130 + x132 * x57))
result[1, 5] = numpy.sum(-0.5 * x128 * (2.0 * x102 + x99))
result[1, 6] = numpy.sum(-0.5 * x135 * (2.0 * x134 + 3.0 * x84))
result[1, 7] = numpy.sum(-x136 * x137)
result[1, 8] = numpy.sum(x137 * (x100 * x124 + x130 * x97))
result[1, 9] = numpy.sum(-x116 * x117 * x135)
result[2, 0] = numpy.sum(x120 * x139)
result[2, 1] = numpy.sum(-x140 * x56)
result[2, 2] = numpy.sum(-x127 * (x123 * x142 + x126 * x144))
result[2, 3] = numpy.sum(-x140 * (x145 + x86))
result[2, 4] = numpy.sum(-x133 * x46 * (x146 + x147 * x57))
result[2, 5] = numpy.sum(-x127 * (x149 + x150 * x57))
result[2, 6] = numpy.sum(-x105 * x135 * x138)
result[2, 7] = numpy.sum(-x137 * (x145 + x151))
result[2, 8] = numpy.sum(-x137 * x152 * x39)
result[2, 9] = numpy.sum(-x135 * x154)
result[3, 0] = numpy.sum(-x108 * (x155 + x157 * x28))
result[3, 1] = numpy.sum(-x87 * (x0 * x48 + x118 * x122 + x118 * x30))
result[3, 2] = numpy.sum(-x61 * (x157 * x71 + x69))
result[3, 3] = numpy.sum(-x61 * (x131 * x160 + x159 + x161 * x20))
result[3, 4] = numpy.sum(-x93 * (x132 * x162 + x162 * x24 + x88))
result[3, 5] = numpy.sum(-x61 * (x101 * x156 * x20 + x163))
result[3, 6] = numpy.sum(-x37 * (x103 + x118 * (2.0 * x134 + 3.0 * x84) + x129 * x34))
result[3, 7] = numpy.sum(-x61 * (x110 + x118 * x136 + x161 * x67))
result[3, 8] = numpy.sum(
-x87 * (x0 * x112 + x118 * x99 + x118 * (2.0 * x101 * x124 + x99))
)
result[3, 9] = numpy.sum(-x108 * (x115 + x116 * x157))
result[4, 0] = numpy.sum(-x138 * x164 * x28)
result[4, 1] = numpy.sum(0.5 * x140 * (-2.0 * x121 + x14 * x2))
result[4, 2] = numpy.sum(-0.5 * x128 * (2.0 * x141 + x30))
result[4, 3] = numpy.sum(-x131 * x165 * x92)
result[4, 4] = numpy.sum(-x133 * x20 * (x124 * x147 + x146))
result[4, 5] = numpy.sum(-x152 * x160 * x92)
result[4, 6] = numpy.sum(0.5 * x119 * x139 * (-2.0 * x134 + 3.0 * x2 * x82))
result[4, 7] = numpy.sum(-0.5 * x127 * (x117 * x166 + 2.0 * x167 * x39))
result[4, 8] = numpy.sum(-x127 * (x124 * x150 + x149))
result[4, 9] = numpy.sum(-x154 * x164)
result[5, 0] = numpy.sum(-x108 * (x155 + x169 * x28))
result[5, 1] = numpy.sum(-x61 * (x169 * x53 + x50))
result[5, 2] = numpy.sum(-x87 * (x0 * x68 + x139 * x142 + x139 * x30))
result[5, 3] = numpy.sum(-x61 * (x159 + x168 * x20 * x85))
result[5, 4] = numpy.sum(-x93 * (x147 * x170 + x170 * x24 + x88))
result[5, 5] = numpy.sum(-x61 * (x163 + x167 * x20 + x171 * x20))
result[5, 6] = numpy.sum(-x108 * (x104 + x105 * x169))
result[5, 7] = numpy.sum(-x87 * (x0 * x109 + x139 * x166 + x139 * x84))
result[5, 8] = numpy.sum(-x61 * (x113 + x167 * x46 + x171 * x46))
result[5, 9] = numpy.sum(-x37 * (x114 + x139 * (2.0 * x153 + 3.0 * x99) + x148 * x34))
return result
[docs]
def int2c2e3d_24(ax, da, A, bx, db, B):
"""Cartesian (d|g) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((6, 15), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - A[0]
x4 = -x2 - B[0]
x5 = bx ** (-1.0)
x6 = ax * x1
x7 = bx * x6 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x8 = boys(5, x7)
x9 = 17.49341832762486
x10 = x5 * x9
x11 = 2.0 * x10
x12 = x0 ** (-1.5) * x11
x13 = x12 * x8
x14 = x13 * x4
x15 = ax ** (-1.0)
x16 = x0 ** (-0.5)
x17 = boys(4, x7)
x18 = 0.5 * x5
x19 = x18 * (-x13 + 2.0 * x15 * x16 * x17 * x5 * x9)
x20 = boys(6, x7)
x21 = x4**2
x22 = x15 * x16
x23 = x11 * x22
x24 = x21 * x23
x25 = x20 * x24
x26 = x12 * x17
x27 = boys(3, x7)
x28 = x18 * (2.0 * x15 * x16 * x27 * x5 * x9 - x26)
x29 = x24 * x8
x30 = x28 + x29
x31 = x12 * x27
x32 = boys(2, x7)
x33 = x18 * (2.0 * x15 * x16 * x32 * x5 * x9 - x31)
x34 = x17 * x23
x35 = x21 * x34
x36 = x33 + x35
x37 = 1.5 * x5
x38 = -x37 * (x30 * x6 - x36) + x4 * (
x4 * (x19 + x25) - x5 * (x14 - 2.0 * x15 * x16 * x17 * x4 * x5 * x9)
)
x39 = x3 * x38
x40 = 0.5 / (ax + bx)
x41 = x26 * x4
x42 = x30 * x4 + x5 * (2.0 * x15 * x16 * x27 * x4 * x5 * x9 - x41)
x43 = x40 * x42
x44 = 4.0 * x43
x45 = x31 * x4
x46 = boys(1, x7)
x47 = x18 * (-x12 * x46 + 2.0 * x15 * x16 * x5 * x9 * boys(0, x7))
x48 = x18 * (-x12 * x32 + 2.0 * x15 * x16 * x46 * x5 * x9)
x49 = x23 * x27
x50 = x21 * x49 + x48
x51 = x23 * x32
x52 = bx * x1
x53 = 0.5 * x15
x54 = x53 * (
x37 * (x21 * x51 + x47 - x50 * x6)
+ x4 * (x36 * x4 + x5 * (2.0 * x15 * x16 * x32 * x4 * x5 * x9 - x45))
+ x52 * (x37 * (x36 * x6 - x50) - x4 * x42)
)
x55 = x36 * x40
x56 = 4.0 * x40
x57 = da * db
x58 = 0.009523809523809524 * x57
x59 = 5.916079783099616 * x58
x60 = -x1 * (ax * A[1] + bx * B[1])
x61 = -x60 - B[1]
x62 = x4 * x61
x63 = x13 * x61
x64 = x5 * (2.0 * x15 * x16 * x17 * x5 * x61 * x9 - x63)
x65 = x25 * x61
x66 = 0.5 * x4 * (x64 + 2.0 * x65) - x5 * (
x13 * x62 - 2.0 * x15 * x16 * x17 * x4 * x5 * x61 * x9
)
x67 = x3 * x66
x68 = x26 * x61
x69 = x5 * (2.0 * x15 * x16 * x27 * x5 * x61 * x9 - x68)
x70 = x29 * x61
x71 = 0.5 * x69 + x70
x72 = x40 * x71
x73 = 3.0 * x72
x74 = x31 * x61
x75 = x5 * (2.0 * x15 * x16 * x32 * x5 * x61 * x9 - x74)
x76 = x35 * x61
x77 = (
0.5
* x53
* (
x4 * (x75 + 2.0 * x76)
+ 2.0 * x5 * (2.0 * x15 * x16 * x32 * x4 * x5 * x61 * x9 - x31 * x62)
- 2.0
* x52
* (x4 * x71 + x5 * (2.0 * x15 * x16 * x27 * x4 * x5 * x61 * x9 - x26 * x62))
)
)
x78 = x10 * x17 * x22
x79 = x56 * x78
x80 = x62 * x79
x81 = 3.0 * x40
x82 = 0.06666666666666667 * x57
x83 = 2.23606797749979 * x82
x84 = -x1 * (ax * A[2] + bx * B[2])
x85 = -x84 - B[2]
x86 = x5 * x85 * (-x13 + 2.0 * x15 * x16 * x17 * x5 * x9)
x87 = 0.5 * x86
x88 = x4 * (x25 * x85 + x87) - x5 * x85 * (x14 - 2.0 * x15 * x16 * x17 * x4 * x5 * x9)
x89 = x3 * x88
x90 = x5 * x85 * (2.0 * x15 * x16 * x27 * x5 * x9 - x26)
x91 = 0.5 * x90
x92 = x29 * x85 + x91
x93 = x40 * x92
x94 = 3.0 * x93
x95 = x5 * x85 * (2.0 * x15 * x16 * x32 * x5 * x9 - x31)
x96 = 0.5 * x95
x97 = x53 * (
x4 * (x35 * x85 + x96)
+ x5 * x85 * (2.0 * x15 * x16 * x32 * x4 * x5 * x9 - x45)
- x52 * (x4 * x92 + x5 * x85 * (2.0 * x15 * x16 * x27 * x4 * x5 * x9 - x41))
)
x98 = x4 * x85
x99 = x79 * x98
x100 = x61**2
x101 = x100 * x23
x102 = x101 * x20
x103 = x102 + x19
x104 = x101 * x8
x105 = x104 + x28
x106 = x100 * x34 + x33
x107 = -x105 * x6 + x106
x108 = x103 * x21 + x107 * x18
x109 = x108 * x3
x110 = 2.0 * x40
x111 = x105 * x4
x112 = x110 * x111
x113 = x100 * x49 + x48
x114 = x100 * x51 - x113 * x6 + x47
x115 = -x106 * x6 + x113
x116 = x53 * (x106 * x21 + x114 * x18 - x52 * (x105 * x21 + x115 * x18))
x117 = x106 * x40
x118 = x3 * x4
x119 = 1.732050807568877
x120 = 0.1111111111111111 * x119 * x57
x121 = x5 * x85 * (2.0 * x15 * x16 * x17 * x5 * x61 * x9 - x63)
x122 = 0.5 * x121 + x65 * x85
x123 = x8 * x85
x124 = x123 * x62
x125 = x10 * x124 * x22 * x56
x126 = x5 * x85 * (2.0 * x15 * x16 * x32 * x5 * x61 * x9 - x74)
x127 = x5 * x85 * (2.0 * x15 * x16 * x27 * x5 * x61 * x9 - x68)
x128 = 0.5 * x53 * (x126 - x52 * (x127 + 2.0 * x70 * x85) + 2.0 * x76 * x85)
x129 = x110 * x78
x130 = x61 * x85
x131 = x118 * x61
x132 = 0.3333333333333333 * x57
x133 = x85**2
x134 = x133 * x23
x135 = x134 * x20 + x19
x136 = x134 * x8 + x28
x137 = x133 * x34 + x33
x138 = -x136 * x6 + x137
x139 = x138 * x18
x140 = x135 * x21 + x139
x141 = x140 * x3
x142 = x136 * x4
x143 = x133 * x49 + x48
x144 = x133 * x51 - x143 * x6 + x47
x145 = x144 * x18
x146 = -x137 * x6 + x143
x147 = x146 * x18
x148 = x53 * (x137 * x21 + x145 - x52 * (x136 * x21 + x147))
x149 = x137 * x40
x150 = x105 * x61 + x69
x151 = x150 * x40
x152 = x103 * x61 + x64
x153 = x118 * x152
x154 = x106 * x61 + x75
x155 = x4 * x52
x156 = x53 * (-x150 * x155 + x154 * x4)
x157 = x104 * x85 + x91
x158 = x157 * x40
x159 = x102 * x85 + x87
x160 = x100 * x34 * x85 + x96
x161 = x53 * (-x155 * x157 + x160 * x4)
x162 = x136 * x61
x163 = x162 * x40
x164 = x53 * (x137 * x4 * x61 - x155 * x162)
x165 = x136 * x85 + x90
x166 = x165 * x40
x167 = x135 * x85 + x86
x168 = x118 * x167
x169 = x137 * x85 + x95
x170 = x53 * (-x155 * x165 + x169 * x4)
x171 = x3**2
x172 = x107 * x37 + x152 * x61
x173 = x53 * (x114 * x37 + x154 * x61 - x52 * (x115 * x37 + x150 * x61))
x174 = x121 + x159 * x61
x175 = x53 * (x126 + x160 * x61 - x52 * (x127 + x157 * x61))
x176 = x100 * x135 + x139
x177 = x53 * (x100 * x137 + x145 - x52 * (x100 * x136 + x147))
x178 = x53 * x61 * (-x165 * x52 + x169)
x179 = x167 * x61
x180 = x138 * x37 + x167 * x85
x181 = x53 * (x144 * x37 + x169 * x85 - x52 * (x146 * x37 + x165 * x85))
x182 = -x60 - A[1]
x183 = 10.2469507659596 * x58
x184 = x182 * x66
x185 = x184 + x43
x186 = x182 * x71 + x55
x187 = 3.872983346207417 * x82
x188 = x108 * x182
x189 = 2.0 * x72
x190 = x188 + x189
x191 = x182 * x4
x192 = x105 * x191 + x80
x193 = x122 * x182 + x93
x194 = x124 * x23
x195 = x110 * (x129 * x98 + x182 * x194)
x196 = x119 * x132
x197 = x136 * x191
x198 = x40 * (3.0 * x117 + x150 * x182)
x199 = x152 * x191
x200 = x111 * x81
x201 = x199 + x200
x202 = x130 * x79
x203 = x40 * (x157 * x182 + x202)
x204 = x125 + x159 * x191
x205 = x40 * (x149 + x162 * x182)
x206 = x135 * x62
x207 = x142 * x40 + x182 * x206
x208 = x166 * x182
x209 = x172 * x182
x210 = 4.0 * x151
x211 = x209 + x210
x212 = x183 * x3
x213 = 3.0 * x158 + x174 * x182
x214 = x187 * x3
x215 = x110 * x162 + x176 * x182
x216 = x132 * x3
x217 = x166 + x179 * x182
x218 = -x84 - A[2]
x219 = x218 * x88 + x43
x220 = x40 * (x218 * x92 + x55)
x221 = x122 * x218 + x72
x222 = x110 * (x129 * x62 + x194 * x218)
x223 = x140 * x218 + 2.0 * x93
x224 = x40 * (x142 * x218 + x99)
x225 = x151 * x218
x226 = x40 * (x117 + x157 * x218)
x227 = x111 * x40
x228 = x218 * x4
x229 = x159 * x228 + x227
x230 = x40 * (x162 * x218 + x202)
x231 = x125 + x206 * x218
x232 = x40 * (3.0 * x149 + x165 * x218)
x233 = x142 * x81 + x167 * x228
x234 = x151 + x174 * x218
x235 = 2.0 * x158 + x176 * x218
x236 = x162 * x81 + x179 * x218
x237 = 4.0 * x166 + x180 * x218
x238 = x182**2
x239 = x182 * x183
x240 = x218 * x43
x241 = x182 * x187
x242 = x218**2
# 90 item(s)
result[0, 0] = numpy.sum(
x59 * (x3 * (x39 + x44) + x54 + x56 * (x3 * x42 + 3.0 * x55))
)
result[0, 1] = numpy.sum(x83 * (x3 * (x67 + x73) + x77 + x81 * (x3 * x71 + x80)))
result[0, 2] = numpy.sum(x83 * (x3 * (x89 + x94) + x81 * (x3 * x92 + x99) + x97))
result[0, 3] = numpy.sum(
x120 * (x110 * (x105 * x118 + x117) + x116 + x3 * (x109 + x112))
)
result[0, 4] = numpy.sum(
x132 * (x110 * (x123 * x131 * x23 + x129 * x130) + x128 + x3 * (x122 * x3 + x125))
)
result[0, 5] = numpy.sum(
x120 * (x110 * (x118 * x136 + x149) + x148 + x3 * (x110 * x142 + x141))
)
result[0, 6] = numpy.sum(x83 * (x151 * x3 + x156 + x3 * (x151 + x153)))
result[0, 7] = numpy.sum(x132 * (x158 * x3 + x161 + x3 * (x118 * x159 + x158)))
result[0, 8] = numpy.sum(x132 * (x163 * x3 + x164 + x3 * (x131 * x135 + x163)))
result[0, 9] = numpy.sum(x83 * (x166 * x3 + x170 + x3 * (x166 + x168)))
result[0, 10] = numpy.sum(x59 * (x171 * x172 + x173))
result[0, 11] = numpy.sum(x83 * (x171 * x174 + x175))
result[0, 12] = numpy.sum(x120 * (x171 * x176 + x177))
result[0, 13] = numpy.sum(x83 * (x171 * x179 + x178))
result[0, 14] = numpy.sum(x59 * (x171 * x180 + x181))
result[1, 0] = numpy.sum(x182 * x183 * (x39 + x44))
result[1, 1] = numpy.sum(x187 * (x185 * x3 + x186 * x81))
result[1, 2] = numpy.sum(x182 * x187 * (x89 + x94))
result[1, 3] = numpy.sum(x132 * (x110 * x192 + x190 * x3))
result[1, 4] = numpy.sum(x196 * (x193 * x3 + x195))
result[1, 5] = numpy.sum(x132 * (x110 * x197 + x141 * x182))
result[1, 6] = numpy.sum(x187 * (x198 + x201 * x3))
result[1, 7] = numpy.sum(x196 * (x203 + x204 * x3))
result[1, 8] = numpy.sum(x196 * (x205 + x207 * x3))
result[1, 9] = numpy.sum(x187 * (x168 * x182 + x208))
result[1, 10] = numpy.sum(x211 * x212)
result[1, 11] = numpy.sum(x213 * x214)
result[1, 12] = numpy.sum(x215 * x216)
result[1, 13] = numpy.sum(x214 * x217)
result[1, 14] = numpy.sum(x180 * x182 * x212)
result[2, 0] = numpy.sum(x183 * x218 * (x39 + x44))
result[2, 1] = numpy.sum(x187 * x218 * (x67 + x73))
result[2, 2] = numpy.sum(x187 * (x219 * x3 + 3.0 * x220))
result[2, 3] = numpy.sum(x132 * x218 * (x109 + x112))
result[2, 4] = numpy.sum(x196 * (x221 * x3 + x222))
result[2, 5] = numpy.sum(x132 * (x223 * x3 + 2.0 * x224))
result[2, 6] = numpy.sum(x187 * (x153 * x218 + x225))
result[2, 7] = numpy.sum(x196 * (x226 + x229 * x3))
result[2, 8] = numpy.sum(x196 * (x230 + x231 * x3))
result[2, 9] = numpy.sum(x187 * (x232 + x233 * x3))
result[2, 10] = numpy.sum(x172 * x212 * x218)
result[2, 11] = numpy.sum(x214 * x234)
result[2, 12] = numpy.sum(x216 * x235)
result[2, 13] = numpy.sum(x214 * x236)
result[2, 14] = numpy.sum(x212 * x237)
result[3, 0] = numpy.sum(x59 * (x238 * x38 + x54))
result[3, 1] = numpy.sum(x83 * (x182 * x185 + x182 * x43 + x77))
result[3, 2] = numpy.sum(x83 * (x238 * x88 + x97))
result[3, 3] = numpy.sum(x120 * (x110 * x186 + x116 + x182 * x190))
result[3, 4] = numpy.sum(x132 * (x128 + x182 * x193 + x182 * x93))
result[3, 5] = numpy.sum(x120 * (x140 * x238 + x148))
result[3, 6] = numpy.sum(x83 * (x156 + x182 * x201 + x192 * x81))
result[3, 7] = numpy.sum(x132 * (x161 + x182 * x204 + x195))
result[3, 8] = numpy.sum(x132 * (x164 + x182 * x207 + x197 * x40))
result[3, 9] = numpy.sum(x83 * (x167 * x238 * x4 + x170))
result[3, 10] = numpy.sum(x59 * (x173 + x182 * x211 + 4.0 * x198))
result[3, 11] = numpy.sum(x83 * (x175 + x182 * x213 + 3.0 * x203))
result[3, 12] = numpy.sum(x120 * (x177 + x182 * x215 + 2.0 * x205))
result[3, 13] = numpy.sum(x83 * (x178 + x182 * x217 + x208))
result[3, 14] = numpy.sum(x59 * (x180 * x238 + x181))
result[4, 0] = numpy.sum(x218 * x239 * x38)
result[4, 1] = numpy.sum(x187 * (x184 * x218 + x240))
result[4, 2] = numpy.sum(x219 * x241)
result[4, 3] = numpy.sum(x132 * x218 * (x188 + x189))
result[4, 4] = numpy.sum(x196 * (x182 * x221 + x220))
result[4, 5] = numpy.sum(x132 * x182 * x223)
result[4, 6] = numpy.sum(x187 * x218 * (x199 + x200))
result[4, 7] = numpy.sum(x196 * (x182 * x229 + x222))
result[4, 8] = numpy.sum(x196 * (x182 * x231 + x224))
result[4, 9] = numpy.sum(x233 * x241)
result[4, 10] = numpy.sum(x183 * x218 * (x209 + x210))
result[4, 11] = numpy.sum(x187 * (x182 * x234 + 3.0 * x226))
result[4, 12] = numpy.sum(x132 * (x182 * x235 + 2.0 * x230))
result[4, 13] = numpy.sum(x187 * (x182 * x236 + x232))
result[4, 14] = numpy.sum(x237 * x239)
result[5, 0] = numpy.sum(x59 * (x242 * x38 + x54))
result[5, 1] = numpy.sum(x83 * (x242 * x66 + x77))
result[5, 2] = numpy.sum(x83 * (x218 * x219 + x240 + x97))
result[5, 3] = numpy.sum(x120 * (x108 * x242 + x116))
result[5, 4] = numpy.sum(x132 * (x128 + x218 * x221 + x218 * x72))
result[5, 5] = numpy.sum(x120 * (x148 + x218 * x223 + 2.0 * x220))
result[5, 6] = numpy.sum(x83 * (x152 * x242 * x4 + x156))
result[5, 7] = numpy.sum(x132 * (x161 + x218 * x227 + x218 * x229))
result[5, 8] = numpy.sum(x132 * (x164 + x218 * x231 + x222))
result[5, 9] = numpy.sum(x83 * (x170 + x218 * x233 + 3.0 * x224))
result[5, 10] = numpy.sum(x59 * (x172 * x242 + x173))
result[5, 11] = numpy.sum(x83 * (x175 + x218 * x234 + x225))
result[5, 12] = numpy.sum(x120 * (x177 + x218 * x235 + 2.0 * x226))
result[5, 13] = numpy.sum(x83 * (x178 + x218 * x236 + 3.0 * x230))
result[5, 14] = numpy.sum(x59 * (x181 + x218 * x237 + 4.0 * x232))
return result
[docs]
def int2c2e3d_30(ax, da, A, bx, db, B):
"""Cartesian (f|s) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((10, 1), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0]) + A[0]
x3 = ax ** (-1.0)
x4 = ax * bx * x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x5 = bx ** (-1.0)
x6 = x3 * (x1 * boys(2, x4) - x5 * boys(1, x4))
x7 = -x6
x8 = 2.0 * x5 * boys(3, x4)
x9 = x2**2 * x8
x10 = 17.49341832762486 * da * db * x0 ** (-0.5) * x3
x11 = 0.2581988897471611 * x10
x12 = -x1 * (ax * A[1] + bx * B[1]) + A[1]
x13 = -x12 * x6
x14 = 0.5773502691896258 * x10
x15 = -x1 * (ax * A[2] + bx * B[2]) + A[2]
x16 = -x15 * x6
x17 = x12**2 * x8
x18 = x17 + x7
x19 = x14 * x2
x20 = x15**2 * x8 + x7
x21 = -x20
# 10 item(s)
result[0, 0] = numpy.sum(x11 * x2 * (2.0 * x6 - x7 - x9))
result[1, 0] = numpy.sum(-x14 * (x12 * x9 + x13))
result[2, 0] = numpy.sum(-x14 * (x15 * x9 + x16))
result[3, 0] = numpy.sum(-x18 * x19)
result[4, 0] = numpy.sum(-x10 * x12 * x15 * x2 * x8)
result[5, 0] = numpy.sum(x19 * x21)
result[6, 0] = numpy.sum(-x11 * (x12 * x18 + 2.0 * x13))
result[7, 0] = numpy.sum(-x14 * (x15 * x17 + x16))
result[8, 0] = numpy.sum(x12 * x14 * x21)
result[9, 0] = numpy.sum(-x11 * (x15 * x20 + 2.0 * x16))
return result
[docs]
def int2c2e3d_31(ax, da, A, bx, db, B):
"""Cartesian (f|p) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((10, 3), dtype=float)
x0 = ax ** (-1.0)
x1 = ax + bx
x2 = x1 ** (-1.0)
x3 = ax * bx * x2 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x4 = boys(2, x3)
x5 = x2 * x4
x6 = boys(3, x3)
x7 = 2.0 * x6
x8 = -x2 * (ax * A[0] + bx * B[0])
x9 = x8 + A[0]
x10 = x8 + B[0]
x11 = x10 * x9
x12 = bx ** (-1.0)
x13 = x12 * boys(1, x3)
x14 = x13 * x2
x15 = x12 * x4
x16 = 2.0 * x15
x17 = -x10
x18 = x2 * x6
x19 = -x15 + x18
x20 = x0 * x19
x21 = x17 * x20
x22 = 2.0 * boys(4, x3)
x23 = x11 * x22 + x18
x24 = x12 * x9
x25 = x23 * x24
x26 = x18 * x24
x27 = x0 * (x13 - x5)
x28 = x12 * x9**2
x29 = 0.5 * x2
x30 = 17.49341832762486 * da * db * x0 * x1 ** (-0.5)
x31 = 0.2581988897471611 * x30
x32 = -x2 * (ax * A[1] + bx * B[1])
x33 = x32 + B[1]
x34 = -x33
x35 = x20 * x34
x36 = x22 * x28
x37 = x33 * x36
x38 = -x9
x39 = -x2 * (ax * A[2] + bx * B[2])
x40 = x39 + B[2]
x41 = -x40
x42 = x20 * x41
x43 = x36 * x40
x44 = x32 + A[1]
x45 = -x44
x46 = 0.5773502691896258 * x30
x47 = x33 * x44
x48 = x0 * (x14 + x16 * x47 - x2 * (x47 * x7 + x5))
x49 = x18 + x22 * x47
x50 = x39 + A[2]
x51 = -x50
x52 = -x0 * x17 * x19 * x51
x53 = -x0 * x19 * x34 * x51
x54 = x40 * x50
x55 = x0 * (x14 + x16 * x54 - x2 * (x5 + x54 * x7))
x56 = 0.5 * x55
x57 = x18 + x22 * x54
x58 = x44**2
x59 = x12 * x22
x60 = x58 * x59
x61 = x10 * x60 + x21
x62 = x12 * x7
x63 = x27 + x58 * x62
x64 = x12 * x44
x65 = x49 * x64
x66 = x18 * x64
x67 = x35 + x65 + x66
x68 = x46 * x9
x69 = x40 * x60 + x42
x70 = x30 * x50
x71 = x50**2
x72 = x59 * x71
x73 = x10 * x72 + x21
x74 = x27 + x62 * x71
x75 = x29 * x74
x76 = x33 * x72 + x35
x77 = x12 * x57
x78 = x12 * x50
x79 = x18 * x78 + x42 + x50 * x77
x80 = x44 * x46
# 30 item(s)
result[0, 0] = numpy.sum(
x31
* (
x0 * (x11 * x16 + x14 - x2 * (x11 * x7 + x5))
+ x29 * (x27 + x28 * x7)
+ x9 * (x21 + x25 + x26)
)
)
result[0, 1] = numpy.sum(-x31 * (2.0 * x0 * x19 * x34 * x38 - x9 * (x35 + x37)))
result[0, 2] = numpy.sum(-x31 * (2.0 * x0 * x19 * x38 * x41 - x9 * (x42 + x43)))
result[1, 0] = numpy.sum(x46 * (-x0 * x17 * x19 * x45 + x25 * x44 + x26 * x44))
result[1, 1] = numpy.sum(0.5 * x46 * (2.0 * x28 * x49 + x48))
result[1, 2] = numpy.sum(x46 * (-x0 * x19 * x41 * x45 + x43 * x44))
result[2, 0] = numpy.sum(x46 * (x25 * x50 + x26 * x50 + x52))
result[2, 1] = numpy.sum(x46 * (x37 * x50 + x53))
result[2, 2] = numpy.sum(x46 * (x28 * x57 + x56))
result[3, 0] = numpy.sum(x46 * (x29 * x63 + x61 * x9))
result[3, 1] = numpy.sum(x67 * x68)
result[3, 2] = numpy.sum(x68 * x69)
result[4, 0] = numpy.sum(x23 * x64 * x70)
result[4, 1] = numpy.sum(x24 * x49 * x70)
result[4, 2] = numpy.sum(x24 * x30 * x44 * x57)
result[5, 0] = numpy.sum(x46 * (x73 * x9 + x75))
result[5, 1] = numpy.sum(x68 * x76)
result[5, 2] = numpy.sum(x68 * x79)
result[6, 0] = numpy.sum(x31 * (-2.0 * x0 * x17 * x19 * x45 + x44 * x61))
result[6, 1] = numpy.sum(x31 * (x29 * x63 + x44 * x67 + x48))
result[6, 2] = numpy.sum(x31 * (-2.0 * x0 * x19 * x41 * x45 + x44 * x69))
result[7, 0] = numpy.sum(x46 * (x10 * x22 * x58 * x78 + x52))
result[7, 1] = numpy.sum(x46 * (x50 * x65 + x50 * x66 + x53))
result[7, 2] = numpy.sum(x46 * (x56 + x58 * x77))
result[8, 0] = numpy.sum(x73 * x80)
result[8, 1] = numpy.sum(x46 * (x44 * x76 + x75))
result[8, 2] = numpy.sum(x79 * x80)
result[9, 0] = numpy.sum(x31 * (-2.0 * x0 * x17 * x19 * x51 + x50 * x73))
result[9, 1] = numpy.sum(x31 * (-2.0 * x0 * x19 * x34 * x51 + x50 * x76))
result[9, 2] = numpy.sum(x31 * (x29 * x74 + x50 * x79 + x55))
return result
[docs]
def int2c2e3d_32(ax, da, A, bx, db, B):
"""Cartesian (f|d) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((10, 6), dtype=float)
x0 = ax ** (-1.0)
x1 = ax + bx
x2 = x1 ** (-1.0)
x3 = -x2 * (ax * A[0] + bx * B[0])
x4 = x3 + A[0]
x5 = bx ** (-1.0)
x6 = ax * bx * x2 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x7 = boys(3, x6)
x8 = x2 * x7
x9 = boys(2, x6)
x10 = x0 * x9
x11 = -x10 + x8
x12 = x11 * x5
x13 = x3 + B[0]
x14 = x13**2
x15 = boys(4, x6)
x16 = 2.0 * x0 * x14 * x15 - x12
x17 = x0 * x13
x18 = 2.0 * x17
x19 = x2 * x9
x20 = -x0 * boys(1, x6) + x19
x21 = x20 * x5
x22 = x4 * x5
x23 = 2.0 * x10 * x2 * x5
x24 = x20 / bx**2
x25 = x0 * x7
x26 = -2.0 * x14 * x25 * x5 + x16 * x2 + x24
x27 = x0 * x26
x28 = x15 * x2
x29 = x5 * (-x25 + x28)
x30 = boys(5, x6)
x31 = -2.0 * x0 * x14 * x30 + x29
x32 = -x31
x33 = x18 * x28 + x32 * x4
x34 = x22 * x33
x35 = x13 * x4
x36 = 2.0 * x35
x37 = x15 * x36 + x8
x38 = x2 * x37
x39 = 2.0 * x0
x40 = x39 * x5
x41 = 0.5 * x4
x42 = -x13
x43 = x0 * (-x5 * x9 + x8)
x44 = x42 * x43
x45 = x0 * x2
x46 = 17.49341832762486 * da * db * x1 ** (-0.5)
x47 = 0.06666666666666667 * x46
x48 = 2.23606797749979 * x47
x49 = -x2 * (ax * A[1] + bx * B[1])
x50 = x49 + B[1]
x51 = -x50
x52 = x43 * x51
x53 = x4**2
x54 = x5 * x53
x55 = 2.0 * x54
x56 = x15 * x50
x57 = 0.5 * x2
x58 = x22 * (x28 + x30 * x36)
x59 = x50 * x58
x60 = x5 * x7
x61 = x28 - x60
x62 = x42 * x61
x63 = x0 * x62
x64 = -x51 * x63
x65 = x22 * x28
x66 = x50 * x65
x67 = x19 * x5
x68 = x0 * (x36 * x60 - x38 + x67)
x69 = 3.872983346207417 * x0 * x47
x70 = -x2 * (ax * A[2] + bx * B[2])
x71 = x70 + B[2]
x72 = -x71
x73 = x43 * x72
x74 = x15 * x71
x75 = x58 * x71
x76 = -x63 * x72
x77 = x65 * x71
x78 = x50**2
x79 = 2.0 * x0 * x15 * x78 - x12
x80 = -2.0 * x0 * x5 * x7 * x78 + x2 * x79 + x24
x81 = -x0 * x80
x82 = -2.0 * x0 * x30 * x78 + x29
x83 = -x82
x84 = -x11 * x5
x85 = x51**2
x86 = x15 * x39
x87 = -x20 * x5
x88 = 2.0 * x25
x89 = x2 * (x84 + x85 * x86) - x5 * (x85 * x88 + x87)
x90 = -x0 * x4
x91 = x51 * x61 * x72
x92 = -x0 * x91
x93 = x30 * x71
x94 = x71**2
x95 = 2.0 * x0 * x15 * x94 - x12
x96 = -2.0 * x0 * x5 * x7 * x94 + x2 * x95 + x24
x97 = -x0 * x96
x98 = -2.0 * x0 * x30 * x94 + x29
x99 = -x98
x100 = x72**2
x101 = x2 * (x100 * x86 + x84) - x5 * (x100 * x88 + x87)
x102 = x42**2
x103 = x2 * (x102 * x86 + x84) - x5 * (x102 * x88 + x87)
x104 = x49 + A[1]
x105 = -x104
x106 = 0.5 * x0
x107 = x105 * x106
x108 = x104 * x5
x109 = x0 * x38
x110 = 0.3333333333333333 * x46
x111 = x104 * x50
x112 = 2.0 * x111
x113 = x112 * x15 + x8
x114 = x113 * x2
x115 = x112 * x30 + x28
x116 = x115 * x35
x117 = x112 * x60 - x113 * x2 + x67
x118 = 1.732050807568877
x119 = x0 * x118
x120 = 0.1666666666666667 * x119 * x46
x121 = x0 * x105
x122 = x121 * x62 * x72
x123 = x110 * x119
x124 = x0 * x50
x125 = 2.0 * x124
x126 = x0 * (
x108 * (2.0 * x0 * x7 * x78 - x21) - x2 * (x104 * x79 + x125 * x8) + x23 * x50
)
x127 = x104 * x83 + x125 * x28
x128 = x0 * x71
x129 = x110 * x118
x130 = x70 + A[2]
x131 = -x130
x132 = x106 * x131
x133 = x103 * x132
x134 = x130 * x5
x135 = x0 * x131
x136 = x135 * x51 * x62
x137 = 2.0 * x130
x138 = x137 * x74 + x8
x139 = x138 * x2
x140 = x137 * x71
x141 = x140 * x30 + x28
x142 = x141 * x35
x143 = -x138 * x2 + x140 * x60 + x67
x144 = -x143
x145 = x132 * x89
x146 = x106 * x143
x147 = 2.0 * x128
x148 = x0 * (
x134 * (2.0 * x0 * x7 * x94 - x21) - x2 * (x130 * x95 + x147 * x8) + x23 * x71
)
x149 = 0.5 * x148
x150 = x130 * x99 + x147 * x28
x151 = -x0 * x26
x152 = x104**2
x153 = x152 * x5
x154 = 2.0 * x32
x155 = x151 + x153 * x154
x156 = 2.0 * x153
x157 = x13 * x15
x158 = x156 * x157 + x44
x159 = x108 * x115
x160 = x13 * x159
x161 = x108 * x28
x162 = x13 * x161
x163 = x160 + x162 + x64
x164 = x108 * x113 + x108 * x8 + x52
x165 = x13 * x156 * x93 + x76
x166 = x57 * (x156 * x74 + x73)
x167 = x0 * x80
x168 = 0.5 * x167
x169 = x108 * x127
x170 = x0 * x5
x171 = x110 * x4
x172 = -x159 * x71 - x161 * x71 - x92
x173 = x119 * x171
x174 = x0 * x96
x175 = 0.5 * x174
x176 = x129 * x130
x177 = x0 * x134
x178 = 0.5 * x139
x179 = x0 * x46
x180 = x111 * x141
x181 = x104 * x110
x182 = x130**2 * x5
x183 = x151 + x154 * x182
x184 = 2.0 * x182
x185 = x157 * x184 + x44
x186 = x13 * x184 * x30 * x50 + x64
x187 = x184 * x56 + x52
x188 = x187 * x57
x189 = x134 * x141
x190 = x134 * x28
x191 = x13 * x189 + x13 * x190 + x76
x192 = x134 * x138 + x134 * x8 + x73
x193 = x192 * x57
x194 = x189 * x50 + x190 * x50 + x92
x195 = -x194
x196 = x134 * x150
x197 = x139 * x170 - x175 + x196
x198 = 0.5 * x104
x199 = x185 * x57
x200 = -x191
x201 = x184 * x83 + x81
x202 = 0.5 * x130
# 60 item(s)
result[0, 0] = numpy.sum(
-x48
* (
x0
* (x13 * x23 - x2 * (x16 * x4 + x18 * x8) + x22 * (2.0 * x0 * x14 * x7 - x21))
+ x41 * (-x27 + 2.0 * x34 + x38 * x40)
+ x45 * (x22 * x37 + x22 * x8 + x44)
)
)
result[0, 1] = numpy.sum(
-x69 * (x4 * (x59 + x64 + x66) + x50 * x68 + x57 * (x52 + x55 * x56))
)
result[0, 2] = numpy.sum(
-x69 * (x4 * (x75 + x76 + x77) + x57 * (x55 * x74 + x73) + x68 * x71)
)
result[0, 3] = numpy.sum(-x48 * (x41 * (x55 * x83 + x81) + x89 * x90))
result[0, 4] = numpy.sum(-x69 * (x4 * (x50 * x55 * x93 + x92) + 2.0 * x90 * x91))
result[0, 5] = numpy.sum(-x48 * (x101 * x90 + x41 * (x55 * x99 + x97)))
result[1, 0] = numpy.sum(-x110 * (x103 * x107 + x104 * x34 + x108 * x109))
result[1, 1] = numpy.sum(
-x120 * (x114 * x22 + x117 * x17 + x22 * (x114 + 2.0 * x116))
)
result[1, 2] = numpy.sum(-x123 * (x104 * x75 + x104 * x77 + x122))
result[1, 3] = numpy.sum(-0.5 * x110 * (x126 + 2.0 * x127 * x54))
result[1, 4] = numpy.sum(-x128 * x129 * (x106 * x117 + x115 * x54))
result[1, 5] = numpy.sum(-x110 * (x101 * x107 + x108 * x53 * x99))
result[2, 0] = numpy.sum(-x110 * (x109 * x134 + x130 * x34 + x133))
result[2, 1] = numpy.sum(-x123 * (x130 * x59 + x130 * x66 + x136))
result[2, 2] = numpy.sum(x120 * (-2.0 * x139 * x22 - 2.0 * x142 * x22 + x144 * x17))
result[2, 3] = numpy.sum(-x110 * (x130 * x54 * x83 + x145))
result[2, 4] = numpy.sum(-x124 * x129 * (x141 * x54 + x146))
result[2, 5] = numpy.sum(-x110 * (x149 + x150 * x54))
result[3, 0] = numpy.sum(-x110 * (x155 * x41 + x158 * x45))
result[3, 1] = numpy.sum(-x123 * (x163 * x4 + x164 * x57))
result[3, 2] = numpy.sum(-x123 * (x165 * x4 + x166))
result[3, 3] = numpy.sum(x171 * (-x114 * x170 + x168 - x169))
result[3, 4] = numpy.sum(x172 * x173)
result[3, 5] = numpy.sum(x171 * (x153 * x98 + x175))
result[4, 0] = numpy.sum(-x108 * x176 * x33)
result[4, 1] = numpy.sum(-0.5 * x177 * x46 * (x114 + 2.0 * x116))
result[4, 2] = numpy.sum(-x108 * x179 * (x142 + x178))
result[4, 3] = numpy.sum(x176 * x22 * (-2.0 * x0 * x15 * x2 * x50 + x104 * x82))
result[4, 4] = numpy.sum(-x179 * x22 * (x178 + x180))
result[4, 5] = numpy.sum(-x118 * x150 * x181 * x22)
result[5, 0] = numpy.sum(-x110 * (x183 * x41 + x185 * x45))
result[5, 1] = numpy.sum(-x123 * (x186 * x4 + x188))
result[5, 2] = numpy.sum(-x123 * (x191 * x4 + x193))
result[5, 3] = numpy.sum(x171 * (x168 + x182 * x82))
result[5, 4] = numpy.sum(x173 * x195)
result[5, 5] = numpy.sum(-x171 * x197)
result[6, 0] = numpy.sum(-x48 * (x103 * x121 + x155 * x198))
result[6, 1] = numpy.sum(-x69 * (x104 * x163 + x117 * x17 + x158 * x57))
result[6, 2] = numpy.sum(-x69 * (x104 * x165 + 2.0 * x122))
result[6, 3] = numpy.sum(
-x48 * (x126 + x164 * x45 + x198 * (x114 * x40 - x167 + 2.0 * x169))
)
result[6, 4] = numpy.sum(x69 * (x104 * x172 - x117 * x128 - x166))
result[6, 5] = numpy.sum(-x48 * (x101 * x121 + x198 * (x156 * x99 + x97)))
result[7, 0] = numpy.sum(-x110 * (x133 + x134 * x152 * x32))
result[7, 1] = numpy.sum(-x123 * (x130 * x160 + x130 * x162 + x136))
result[7, 2] = numpy.sum(-x129 * x17 * (x141 * x153 + x146))
result[7, 3] = numpy.sum(-x110 * (x114 * x177 + x130 * x169 + x145))
result[7, 4] = numpy.sum(
x120 * (-2.0 * x108 * x139 - 2.0 * x108 * x180 + x124 * x144)
)
result[7, 5] = numpy.sum(-x110 * (x149 + x150 * x153))
result[8, 0] = numpy.sum(0.5 * x181 * (2.0 * x182 * x31 + x27))
result[8, 1] = numpy.sum(-x123 * (x104 * x186 + x199))
result[8, 2] = numpy.sum(x119 * x181 * x200)
result[8, 3] = numpy.sum(-x110 * (x187 * x45 + x198 * x201))
result[8, 4] = numpy.sum(-x123 * (x104 * x194 + x193))
result[8, 5] = numpy.sum(-x181 * x197)
result[9, 0] = numpy.sum(-x48 * (x103 * x135 + x183 * x202))
result[9, 1] = numpy.sum(-x69 * (x130 * x186 + 2.0 * x136))
result[9, 2] = numpy.sum(x69 * (x130 * x200 - x143 * x17 - x199))
result[9, 3] = numpy.sum(-x48 * (x135 * x89 + x201 * x202))
result[9, 4] = numpy.sum(x69 * (-x124 * x143 + x130 * x195 - x188))
result[9, 5] = numpy.sum(
-x48 * (x148 + x192 * x45 + x202 * (x139 * x40 - x174 + 2.0 * x196))
)
return result
[docs]
def int2c2e3d_33(ax, da, A, bx, db, B):
"""Cartesian (f|f) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((10, 10), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = x2 + B[0]
x4 = bx ** (-1.0)
x5 = ax * bx * x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x6 = boys(4, x5)
x7 = x1 * x6
x8 = ax ** (-1.0)
x9 = boys(3, x5)
x10 = x8 * x9
x11 = -x10 + x7
x12 = x11 * x4
x13 = x3**2
x14 = boys(5, x5)
x15 = x12 - 2.0 * x13 * x14 * x8
x16 = -x15
x17 = -x3
x18 = 2.0 * x17
x19 = x12 * x18 + x16 * x3
x20 = x2 + A[0]
x21 = 2.0 * x20
x22 = x1 * x9
x23 = boys(2, x5)
x24 = x22 - x23 * x8
x25 = x24 * x4
x26 = 2.0 * x13 * x6 * x8 - x25
x27 = x1 * x26
x28 = x26 * x3
x29 = x21 * x4
x30 = x1 * x23 - x8 * boys(1, x5)
x31 = x30 * x4
x32 = 2.0 * x13 * x8 * x9 - x31
x33 = 3.0 * x1
x34 = x33 * x4
x35 = 2.0 * x8
x36 = bx ** (-2.0)
x37 = x24 * x36
x38 = -x1 * x19 + x18 * x37 + x28 * x4
x39 = x38 * x8
x40 = x1 * x14
x41 = x6 * x8
x42 = x4 * (x40 - x41)
x43 = boys(6, x5)
x44 = x18 * x42 + x3 * (2.0 * x13 * x43 * x8 - x42)
x45 = x20 * x44
x46 = x1 * x16
x47 = x20 * x4
x48 = x47 * (2.0 * x45 + 3.0 * x46)
x49 = x3 * x35
x50 = x49 * x7
x51 = x16 * x20 + x50
x52 = x30 * x36
x53 = 2.0 * x13
x54 = -x10 * x4 * x53 + x27 + x52
x55 = x54 * x8
x56 = x21 * x3
x57 = x1 * x4
x58 = x35 * x57
x59 = 17.49341832762486 * da * db * x0 ** (-0.5)
x60 = 0.01666666666666667 * x59
x61 = -x1 * (ax * A[1] + bx * B[1])
x62 = x61 + B[1]
x63 = -x62
x64 = x12 * x63
x65 = x13 * x35
x66 = x14 * x65
x67 = x62 * x66 + x64
x68 = x25 * x63
x69 = x41 * x53
x70 = x62 * x69
x71 = x68 + x70
x72 = 2.0 * x10
x73 = x57 * x72
x74 = x62 * x73
x75 = x37 * x63
x76 = -x1 * x67 + x4 * x70 + x75
x77 = x42 * x63
x78 = x43 * x65
x79 = x62 * x78 + x77
x80 = x40 * x49
x81 = x20 * x79 + x62 * x80
x82 = x35 * x62
x83 = x14 * x56 + x7
x84 = x1 * x83
x85 = x4 * x84
x86 = x47 * x83
x87 = -x4 * x9 + x7
x88 = x17 * x8
x89 = x87 * x88
x90 = -x63 * x89
x91 = x47 * x7
x92 = x1 * x8
x93 = 2.23606797749979
x94 = 0.06666666666666667 * x59
x95 = x93 * x94
x96 = -x1 * (ax * A[2] + bx * B[2])
x97 = x96 + B[2]
x98 = -x97
x99 = x12 * x98
x100 = x66 * x97 + x99
x101 = x25 * x98
x102 = x69 * x97
x103 = x101 + x102
x104 = x73 * x97
x105 = x37 * x98
x106 = -x1 * x100 + x102 * x4 + x105
x107 = x42 * x98
x108 = x107 + x78 * x97
x109 = x108 * x20 + x80 * x97
x110 = x35 * x97
x111 = -x89 * x98
x112 = x62**2
x113 = -2.0 * x112 * x6 * x8 + x25
x114 = -x113
x115 = x1 * x114
x116 = 2.0 * x112
x117 = x10 * x116
x118 = x115 - x117 * x4 + x52
x119 = x118 * x8
x120 = x14 * x35
x121 = x112 * x120
x122 = x12 - x121
x123 = x20**2
x124 = x123 * x4
x125 = 2.0 * x124
x126 = -x117 + x31
x127 = x29 * x3
x128 = -x11 * x4
x129 = x63**2
x130 = x120 * x129
x131 = -x24 * x4
x132 = 2.0 * x41
x133 = x129 * x132
x134 = x1 * (x128 + x130) - x4 * (x131 + x133)
x135 = x134 * x88
x136 = -x122
x137 = x1 * x136
x138 = 2.0 * x112 * x43 * x8 - x42
x139 = x47 * (x137 + x138 * x56)
x140 = x137 * x47
x141 = x60 * x93
x142 = x4 * x6
x143 = x63 * x88 * x98 * (-x142 + x40)
x144 = x62 * x97
x145 = x144 * x47
x146 = x63 * x8
x147 = -x146 * x87 * x98
x148 = 0.5 * x1
x149 = x22 * x4
x150 = x62 * x8
x151 = 3.872983346207417 * x94
x152 = x151 * x8
x153 = x97**2
x154 = -2.0 * x153 * x6 * x8 + x25
x155 = -x154
x156 = x1 * x155
x157 = x153 * x72
x158 = x156 - x157 * x4 + x52
x159 = x158 * x8
x160 = x12 - x120 * x153
x161 = x1 * x154
x162 = -x157 + x31
x163 = x162 * x57
x164 = x98**2
x165 = x120 * x164
x166 = x132 * x164
x167 = x1 * (x128 + x165) - x4 * (x131 + x166)
x168 = x167 * x88
x169 = -x160
x170 = x1 * x169
x171 = -2.0 * x153 * x43 * x8 + x42
x172 = -x171
x173 = x47 * (x170 + x172 * x56)
x174 = x170 * x47
x175 = x136 * x62 + 2.0 * x64
x176 = x114 * x62
x177 = -x1 * x175 + x176 * x4 + 2.0 * x75
x178 = x177 * x8
x179 = x138 * x62 + 2.0 * x77
x180 = 0.5 * x20
x181 = -x20
x182 = 3.0 * x128
x183 = 3.0 * x131
x184 = x1 * (x130 + x182) - x4 * (x133 + x183)
x185 = x146 * x184
x186 = x121 * x97 + x99
x187 = x116 * x41 * x97
x188 = -x1 * x186 + x105 + x187 * x4
x189 = x188 * x8
x190 = x107 + x112 * x35 * x43 * x97
x191 = x8 * x98
x192 = x181 * x191
x193 = x146 * x167
x194 = x169 * x97 + 2.0 * x99
x195 = x155 * x97
x196 = -x1 * x194 + 2.0 * x105 + x195 * x4
x197 = x196 * x8
x198 = 2.0 * x107 + x172 * x97
x199 = x1 * (x165 + x182) - x4 * (x166 + x183)
x200 = x61 + A[1]
x201 = -x200
x202 = x17**2
x203 = x120 * x202
x204 = x132 * x202
x205 = x1 * (x182 + x203) - x4 * (x183 + x204)
x206 = x200 * x4
x207 = x33 * x51
x208 = 0.03333333333333333 * x59 * x93
x209 = 2.0 * x200
x210 = x32 * x57
x211 = x209 * x4
x212 = -x8 * (-x1 * (x209 * x67 + x27) + x210 + x211 * x71)
x213 = x209 * x79 + x46
x214 = x20 * x213
x215 = x209 * x62
x216 = x14 * x215 + x7
x217 = x1 * x216
x218 = x217 * x49
x219 = x1 * (x215 * x6 + x22)
x220 = 0.08333333333333333 * x59
x221 = x200 * x47
x222 = x1 * (x128 + x203) - x4 * (x131 + x204)
x223 = x206 * x97
x224 = 0.3333333333333333 * x59
x225 = x136 * x200 + x7 * x82
x226 = x1 * x225
x227 = x3 * x8
x228 = x138 * x200 + x40 * x82
x229 = 0.1666666666666667 * x59
x230 = x227 * (x142 * x215 + x149 - x217)
x231 = x215 * x43 + x40
x232 = x8 * x97
x233 = 1.732050807568877
x234 = x229 * x233
x235 = -x167 * x17 * x201 * x8
x236 = -x126
x237 = -x8 * (
-x1 * (3.0 * x115 + x175 * x209) + x211 * (x176 + 2.0 * x68) + x236 * x34
)
x238 = x179 * x200
x239 = 3.0 * x137 + 2.0 * x238
x240 = x144 * x35
x241 = x101 + x187
x242 = -x8 * (-x1 * (x186 * x200 + x240 * x7) + x144 * x73 + x206 * x241)
x243 = x190 * x200 + x240 * x40
x244 = x1 * (x160 * x215 + x161) - x154 * x211 * x62 - x163
x245 = x96 + A[2]
x246 = -x245
x247 = x245 * x4
x248 = x245 * x47
x249 = 2.0 * x245
x250 = x249 * x4
x251 = -x8 * (-x1 * (x100 * x249 + x27) + x103 * x250 + x210)
x252 = -x251
x253 = x108 * x249 + x46
x254 = x20 * x253
x255 = x249 * x97
x256 = x14 * x255 + x7
x257 = x1 * x256
x258 = x257 * x49
x259 = x1 * (x22 + x255 * x6)
x260 = -x134 * x17 * x246 * x8
x261 = x142 * x255 + x149 - x257
x262 = x227 * x261
x263 = x255 * x43 + x40
x264 = x110 * x7 + x169 * x245
x265 = x1 * x264
x266 = x104 + x155 * x247 - x265
x267 = x110 * x40 + x172 * x245
x268 = -x8 * (-x1 * (x115 + x186 * x249) + x236 * x57 + x241 * x250)
x269 = -x268
x270 = x137 + x190 * x249
x271 = (
2.0 * x1 * x4 * x8 * x9 * x97
- x1 * (2.0 * x1 * x6 * x8 * x97 - x160 * x245)
- x154 * x247
)
x272 = x271 * x8
x273 = 0.5 * x272
x274 = 2.0 * x1 * x14 * x8 * x97 - x171 * x245
x275 = x8 * (
x1 * (3.0 * x156 + x194 * x249) + x162 * x34 - x250 * (2.0 * x101 + x195)
)
x276 = -x275
x277 = x198 * x245
x278 = 3.0 * x170 + 2.0 * x277
x279 = -x54 * x8
x280 = x200**2
x281 = x280 * x4
x282 = 2.0 * x281
x283 = x38 * x8
x284 = -x282 * x44 - x283
x285 = x76 * x8
x286 = x206 * x213
x287 = x206 * x46
x288 = x285 + x286 + x287
x289 = x206 * x216
x290 = x206 * x3
x291 = x289 * x3 + x290 * x7 + x90
x292 = x106 * x8
x293 = -x108 * x282 - x292
x294 = x282 * x3
x295 = x111 + x14 * x294 * x97
x296 = -x118 * x8
x297 = x35 * x4
x298 = x211 * x225 + x219 * x297
x299 = x135 + x211 * x228 * x3 + x218 * x4
x300 = x290 * x97
x301 = x143 + x231 * x300 + x300 * x40
x302 = x147 + x223 * x7 + x289 * x97
x303 = x224 * x233
x304 = x303 * x8
x305 = -x158 * x8
x306 = x168 + x172 * x294
x307 = x177 * x8
x308 = x206 * x239
x309 = 3.0 * x4
x310 = x226 * x309 + x307 + x308
x311 = x20 * x208
x312 = x188 * x8
x313 = x217 * x4
x314 = x20 * x224
x315 = x170 * x206 + x193 + x206 * (x170 + x172 * x215)
x316 = x20 * x229
x317 = x196 * x8
x318 = x198 * x281
x319 = x20 * x95
x320 = x217 * x227
x321 = x247 * x303
x322 = x227 * x257
x323 = x206 * x303
x324 = x20 * x3
x325 = x1 * (x215 * x256 + x259)
x326 = x215 * x263 + x257
x327 = 0.5 * x265
x328 = x200 * x270
x329 = x150 * x257
x330 = x303 * x47
x331 = x267 * x62
x332 = x245**2 * x4
x333 = 2.0 * x332
x334 = x1 * (x16 * x333 + x279)
x335 = x332 * x44
x336 = -x283 - 2.0 * x335
x337 = -x285 - x333 * x79
x338 = x3 * x333
x339 = x14 * x338 * x62 + x90
x340 = x339 * x92
x341 = x247 * x253 + x247 * x46 + x292
x342 = x247 * x256
x343 = x247 * x3
x344 = x111 + x3 * x342 + x343 * x7
x345 = x1 * (x136 * x333 + x296)
x346 = x135 + x138 * x338
x347 = x343 * x62
x348 = x143 + x263 * x347 + x347 * x40
x349 = x147 + x247 * x62 * x7 + x342 * x62
x350 = x250 * x264 + x259 * x297
x351 = x1 * (x305 + x350)
x352 = x168 + x250 * x267 * x3 + x258 * x4
x353 = x179 * x332
x354 = x137 * x247 + x189 + x247 * x270
x355 = x247 * x278 + x265 * x309 + x317
x356 = 0.5 * x200
x357 = x205 * x88
x358 = x191 * x201
x359 = x257 * x82
x360 = -x178 - 2.0 * x353
x361 = x193 + x250 * x331 + x359 * x4
x362 = 0.5 * x245
# 100 item(s)
result[0, 0] = numpy.sum(
x60
* (
x21 * (x34 * x51 + x39 + x48)
+ x33 * (x29 * x51 - x55 + x58 * (x22 + x56 * x6))
+ x35 * (-x1 * (x19 * x21 + 3.0 * x27) + x29 * (x18 * x25 + x28) + x32 * x34)
)
)
result[0, 1] = numpy.sum(
0.5
* x95
* (
x20 * (x29 * x81 + x76 * x8 + x82 * x85)
+ 2.0 * x8 * (-x1 * (x20 * x67 + x50 * x62) + x3 * x74 + x47 * x71)
+ 2.0 * x92 * (x62 * x86 + x62 * x91 + x90)
)
)
result[0, 2] = numpy.sum(
0.5
* x95
* (
x20 * (x106 * x8 + x109 * x29 + x110 * x85)
+ 2.0 * x8 * (-x1 * (x100 * x20 + x50 * x97) + x103 * x47 + x104 * x3)
+ 2.0 * x92 * (x111 + x86 * x97 + x91 * x97)
)
)
result[0, 3] = numpy.sum(
-x141
* (
x1 * (x119 + x122 * x125)
- x21 * (x135 + x139 + x140)
+ x35 * (-x1 * (x1 * x113 + x122 * x56) + x113 * x127 + x126 * x57)
)
)
result[0, 4] = numpy.sum(
x152
* (
x148 * (x125 * x14 * x144 + x147)
+ x150 * x97 * (x142 * x56 + x149 - x84)
+ x20 * (x143 + x145 * x40 + x145 * (x40 + x43 * x56))
)
)
result[0, 5] = numpy.sum(
-x141
* (
x1 * (x125 * x160 + x159)
- x21 * (x168 + x173 + x174)
+ x35 * (-x1 * (x160 * x56 + x161) + x127 * x154 + x163)
)
)
result[0, 6] = numpy.sum(x94 * (x180 * (x125 * x179 + x178) - x181 * x185))
result[0, 7] = numpy.sum(-x95 * (x134 * x192 - x180 * (x125 * x190 + x189)))
result[0, 8] = numpy.sum(
-x95 * (x167 * x181 * x63 * x8 - x180 * (x125 * x172 * x62 + x193))
)
result[0, 9] = numpy.sum(x94 * (x180 * (x125 * x198 + x197) - x192 * x199))
result[1, 0] = numpy.sum(x208 * (-x17 * x201 * x205 * x8 + x200 * x48 + x206 * x207))
result[1, 1] = numpy.sum(
x220 * (-x212 + x29 * (x214 + x218) + x58 * (x216 * x56 + x219))
)
result[1, 2] = numpy.sum(
0.5 * x224 * (2.0 * x109 * x221 - x201 * x222 * x8 * x98 + 2.0 * x223 * x8 * x84)
)
result[1, 3] = numpy.sum(
x229
* (x226 * x47 + x227 * (x114 * x206 - x226 + x74) + x47 * (x226 + x228 * x56))
)
result[1, 4] = numpy.sum(
x232 * x234 * (x217 * x47 + x230 + x47 * (x217 + x231 * x56))
)
result[1, 5] = numpy.sum(x229 * (x173 * x200 + x174 * x200 + x235))
result[1, 6] = numpy.sum(x141 * (x125 * x239 - x237))
result[1, 7] = numpy.sum(0.5 * x224 * (2.0 * x124 * x243 - x242))
result[1, 8] = numpy.sum(-x220 * (x125 * (x1 * x160 + x171 * x215) - x244 * x8))
result[1, 9] = numpy.sum(
0.5 * x95 * (2.0 * x123 * x198 * x206 - x199 * x201 * x8 * x98)
)
result[2, 0] = numpy.sum(x208 * (-x17 * x205 * x246 * x8 + x207 * x247 + x245 * x48))
result[2, 1] = numpy.sum(
0.5 * x224 * (2.0 * x150 * x247 * x84 - x222 * x246 * x63 * x8 + 2.0 * x248 * x81)
)
result[2, 2] = numpy.sum(
x220 * (x252 + x29 * (x254 + x258) + x58 * (x256 * x56 + x259))
)
result[2, 3] = numpy.sum(x229 * (x139 * x245 + x140 * x245 + x260))
result[2, 4] = numpy.sum(
x150 * x234 * (x257 * x47 + x262 + x47 * (x257 + x263 * x56))
)
result[2, 5] = numpy.sum(
x229 * (x227 * x266 + x265 * x47 + x47 * (x265 + x267 * x56))
)
result[2, 6] = numpy.sum(
0.5 * x95 * (2.0 * x124 * x179 * x245 - x184 * x246 * x63 * x8)
)
result[2, 7] = numpy.sum(x220 * (x125 * x270 + x269))
result[2, 8] = numpy.sum(x224 * x62 * (x124 * x274 + x273))
result[2, 9] = numpy.sum(x141 * (x125 * x278 + x276))
result[3, 0] = numpy.sum(-x141 * (x21 * x284 - x33 * (x16 * x282 + x279)))
result[3, 1] = numpy.sum(x224 * (x180 * x288 + x291 * x92))
result[3, 2] = numpy.sum(x224 * (-x180 * x293 + x295 * x92))
result[3, 3] = numpy.sum(x220 * (x1 * (x296 + x298) + x21 * x299))
result[3, 4] = numpy.sum(x304 * (x148 * x302 + x20 * x301))
result[3, 5] = numpy.sum(x220 * (x1 * (x169 * x282 + x305) + x21 * x306))
result[3, 6] = numpy.sum(x310 * x311)
result[3, 7] = numpy.sum(0.5 * x314 * (2.0 * x206 * x243 + 2.0 * x232 * x313 + x312))
result[3, 8] = numpy.sum(x315 * x316)
result[3, 9] = numpy.sum(0.5 * x319 * (x317 + 2.0 * x318))
result[4, 0] = numpy.sum(0.5 * x151 * x206 * x245 * (2.0 * x45 + 3.0 * x46))
result[4, 1] = numpy.sum(0.5 * x321 * (x214 + 2.0 * x320))
result[4, 2] = numpy.sum(0.5 * x323 * (x254 + 2.0 * x322))
result[4, 3] = numpy.sum(0.5 * x321 * (x226 + 2.0 * x228 * x324))
result[4, 4] = numpy.sum(0.25 * x4 * x59 * x8 * (x325 + x326 * x56))
result[4, 5] = numpy.sum(x323 * (x274 * x324 + x327))
result[4, 6] = numpy.sum(0.5 * x151 * x248 * (-3.0 * x1 * x122 + 2.0 * x238))
result[4, 7] = numpy.sum(0.5 * x330 * (x328 + 2.0 * x329))
result[4, 8] = numpy.sum(x330 * (x200 * x331 + x327))
result[4, 9] = numpy.sum(0.5 * x151 * x221 * (3.0 * x170 + 2.0 * x277))
result[5, 0] = numpy.sum(x141 * (-x21 * x336 + 3.0 * x334))
result[5, 1] = numpy.sum(x224 * (-x180 * x337 + x340))
result[5, 2] = numpy.sum(x224 * (x180 * x341 + x344 * x92))
result[5, 3] = numpy.sum(x220 * (x21 * x346 + x345))
result[5, 4] = numpy.sum(x304 * (x148 * x349 + x20 * x348))
result[5, 5] = numpy.sum(x220 * (x21 * x352 + x351))
result[5, 6] = numpy.sum(0.5 * x319 * (x307 + 2.0 * x353))
result[5, 7] = numpy.sum(x316 * x354)
result[5, 8] = numpy.sum(0.5 * x314 * (x193 + 2.0 * x247 * x331 + 2.0 * x329 * x4))
result[5, 9] = numpy.sum(x311 * x355)
result[6, 0] = numpy.sum(-x94 * (x201 * x357 + x284 * x356))
result[6, 1] = numpy.sum(
-x141 * (x1 * (x15 * x282 + x55) - 2.0 * x200 * x288 + 2.0 * x212)
)
result[6, 2] = numpy.sum(-x95 * (x222 * x358 + x293 * x356))
result[6, 3] = numpy.sum(
x95
* (
-x227
* (
-2.0 * x1 * x4 * x62 * x8 * x9
+ x1 * (2.0 * x1 * x6 * x62 * x8 - x122 * x200)
+ x113 * x206
)
+ x291 * x92
+ x299 * x356
)
)
result[6, 4] = numpy.sum(x152 * (x148 * x295 + x200 * x301 + x230 * x97))
result[6, 5] = numpy.sum(x95 * (x235 + x306 * x356))
result[6, 6] = numpy.sum(-x60 * (-x209 * x310 + 2.0 * x237 + x33 * (x119 - x298)))
result[6, 7] = numpy.sum(
0.5
* x95
* (x200 * (x110 * x313 + x211 * x243 + x312) - 2.0 * x242 + 2.0 * x302 * x92)
)
result[6, 8] = numpy.sum(
x141 * (-x1 * (x159 + x160 * x282) + x209 * x315 + 2.0 * x244 * x8)
)
result[6, 9] = numpy.sum(-x94 * (x199 * x358 - x356 * (x197 + 2.0 * x318)))
result[7, 0] = numpy.sum(
0.5 * x95 * (-x17 * x205 * x246 * x8 + 2.0 * x247 * x280 * x44)
)
result[7, 1] = numpy.sum(x229 * (-x222 * x246 * x63 * x8 + x245 * x286 + x245 * x287))
result[7, 2] = numpy.sum(x220 * (x252 + x253 * x282))
result[7, 3] = numpy.sum(
0.5
* x224
* (-x134 * x17 * x246 * x8 + 2.0 * x228 * x245 * x290 + 2.0 * x247 * x320)
)
result[7, 4] = numpy.sum(x227 * x234 * (x150 * x261 + x206 * x257 + x206 * x326))
result[7, 5] = numpy.sum(x224 * x3 * (x273 + x274 * x281))
result[7, 6] = numpy.sum(
x208 * (-x184 * x246 * x63 * x8 + 3.0 * x226 * x247 + x245 * x308)
)
result[7, 7] = numpy.sum(x220 * (x211 * (x328 + x359) + x269 + x297 * x325))
result[7, 8] = numpy.sum(
x229 * (x150 * x266 + x206 * x265 + x206 * (x209 * x331 + x265))
)
result[7, 9] = numpy.sum(x141 * (x276 + x278 * x282))
result[8, 0] = numpy.sum(0.5 * x200 * x95 * (2.0 * x335 + x39))
result[8, 1] = numpy.sum(x220 * (-x209 * x337 + x334))
result[8, 2] = numpy.sum(x200 * x229 * x341)
result[8, 3] = numpy.sum(x224 * (x340 + x346 * x356))
result[8, 4] = numpy.sum(x304 * (x148 * x344 + x200 * x348))
result[8, 5] = numpy.sum(
0.5 * x200 * x224 * (x168 + 2.0 * x267 * x343 + 2.0 * x322 * x4)
)
result[8, 6] = numpy.sum(x141 * (-x209 * x360 + 3.0 * x345))
result[8, 7] = numpy.sum(x224 * (x349 * x92 + x354 * x356))
result[8, 8] = numpy.sum(x220 * (x209 * x361 + x351))
result[8, 9] = numpy.sum(x200 * x208 * x355)
result[9, 0] = numpy.sum(-x94 * (x246 * x357 + x336 * x362))
result[9, 1] = numpy.sum(-x95 * (x146 * x222 * x246 + x337 * x362))
result[9, 2] = numpy.sum(
-x141 * (x1 * (x15 * x333 + x55) - 2.0 * x245 * x341 + 2.0 * x251)
)
result[9, 3] = numpy.sum(x95 * (x260 + x346 * x362))
result[9, 4] = numpy.sum(x152 * (x148 * x339 + x245 * x348 + x262 * x62))
result[9, 5] = numpy.sum(x95 * (x227 * x271 + x344 * x92 + x352 * x362))
result[9, 6] = numpy.sum(-x94 * (x185 * x246 + x360 * x362))
result[9, 7] = numpy.sum(
-x141 * (x1 * (x119 + x122 * x333) - 2.0 * x245 * x354 + 2.0 * x268)
)
result[9, 8] = numpy.sum(x95 * (x272 * x62 + x349 * x92 + x361 * x362))
result[9, 9] = numpy.sum(-x60 * (-x249 * x355 + 2.0 * x275 + x33 * (x159 - x350)))
return result
[docs]
def int2c2e3d_34(ax, da, A, bx, db, B):
"""Cartesian (f|g) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((10, 15), dtype=float)
x0 = ax ** (-1.0)
x1 = ax + bx
x2 = x1 ** (-1.0)
x3 = -x2 * (ax * A[0] + bx * B[0])
x4 = -x3 - A[0]
x5 = -x3 - B[0]
x6 = bx ** (-1.0)
x7 = ax * x2
x8 = bx * x7 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x9 = boys(4, x8)
x10 = x1 ** (-1.5)
x11 = 17.49341832762486
x12 = x11 * x6
x13 = 2.0 * x12
x14 = x10 * x13
x15 = x14 * x9
x16 = x15 * x5
x17 = x1 ** (-0.5)
x18 = boys(3, x8)
x19 = 0.5 * x6
x20 = x19 * (2.0 * x0 * x11 * x17 * x18 * x6 - x15)
x21 = x5**2
x22 = boys(5, x8)
x23 = x0 * x17
x24 = x13 * x23
x25 = x22 * x24
x26 = x21 * x25
x27 = x20 + x26
x28 = x27 * x5 + x6 * (2.0 * x0 * x11 * x17 * x18 * x5 * x6 - x16)
x29 = boys(2, x8)
x30 = x19 * (2.0 * x0 * x11 * x17 * x6 * boys(1, x8) - x14 * x29)
x31 = x14 * x18
x32 = x19 * (2.0 * x0 * x11 * x17 * x29 * x6 - x31)
x33 = x24 * x9
x34 = x21 * x33
x35 = x32 + x34
x36 = x18 * x24
x37 = 1.5 * x6
x38 = x28 * x5 + x37 * (x21 * x36 + x30 - x35 * x7)
x39 = 0.5 / (ax + bx)
x40 = x5 * (x35 + x6 * (2.0 * x0 * x11 * x17 * x29 * x6 - x31))
x41 = x39 * x40
x42 = x14 * x22
x43 = x42 * x5
x44 = x19 * (2.0 * x0 * x11 * x17 * x6 * x9 - x42)
x45 = boys(6, x8)
x46 = x21 * x24
x47 = x45 * x46
x48 = x44 + x47
x49 = x48 * x5 + x6 * (2.0 * x0 * x11 * x17 * x5 * x6 * x9 - x43)
x50 = -x37 * (x27 * x7 - x35) + x49 * x5
x51 = x28 * x39
x52 = bx * x2
x53 = x14 * x45
x54 = x5 * x53
x55 = x19 * (2.0 * x0 * x11 * x17 * x22 * x6 - x53)
x56 = boys(7, x8)
x57 = x46 * x56
x58 = x37 * (x27 - x48 * x7) + x5 * (
x5 * (x55 + x57) + x6 * (2.0 * x0 * x11 * x17 * x22 * x5 * x6 - x54)
)
x59 = x4 * x58
x60 = x39 * x49
x61 = 4.0 * x60
x62 = x50 * x52
x63 = 0.5 * x0
x64 = x63 * (x38 - x62)
x65 = x4 * x49
x66 = x27 * x39
x67 = 3.0 * x66
x68 = x65 + x67
x69 = 4.0 * x39
x70 = x63 * (-x28 * x52 + x40)
x71 = x12 * x23
x72 = x71 * x9
x73 = x5 * x72
x74 = 3.0 * x39
x75 = da * db
x76 = 0.009523809523809524 * x75
x77 = 2.645751311064591 * x76
x78 = -x2 * (ax * A[1] + bx * B[1])
x79 = -x78 - B[1]
x80 = x5 * x79
x81 = x15 * x79
x82 = x6 * (2.0 * x0 * x11 * x17 * x18 * x6 * x79 - x81)
x83 = x26 * x79
x84 = 0.5 * x82 + x83
x85 = x5 * x84 + x6 * (2.0 * x0 * x11 * x17 * x18 * x5 * x6 * x79 - x15 * x80)
x86 = x6 * x79 * (2.0 * x0 * x11 * x17 * x29 * x6 - x31)
x87 = x34 * x79 + 0.5 * x86
x88 = x39 * x87
x89 = x42 * x79
x90 = x6 * (2.0 * x0 * x11 * x17 * x6 * x79 * x9 - x89)
x91 = x47 * x79
x92 = 0.5 * x90 + x91
x93 = x5 * x92 + x6 * (2.0 * x0 * x11 * x17 * x5 * x6 * x79 * x9 - x42 * x80)
x94 = x39 * x84
x95 = x53 * x79
x96 = x6 * (2.0 * x0 * x11 * x17 * x22 * x6 * x79 - x95)
x97 = x57 * x79
x98 = 0.5 * x5 * (x96 + 2.0 * x97) + x6 * (
2.0 * x0 * x11 * x17 * x22 * x5 * x6 * x79 - x53 * x80
)
x99 = x4 * x98
x100 = x39 * x92
x101 = 3.0 * x100
x102 = x52 * x93
x103 = x63 * (-x102 + x85)
x104 = x4 * x92
x105 = x22 * x80
x106 = x69 * x71
x107 = x105 * x106
x108 = x104 + x107
x109 = x63 * (-x52 * x84 + x87)
x110 = 2.0 * x39
x111 = x110 * x72
x112 = x111 * x79
x113 = x4 * x5
x114 = x25 * x79
x115 = 0.06666666666666667 * x75
x116 = -x2 * (ax * A[2] + bx * B[2])
x117 = -x116 - B[2]
x118 = x117 * x6 * (2.0 * x0 * x11 * x17 * x18 * x6 - x15)
x119 = 0.5 * x118
x120 = x117 * x26 + x119
x121 = x117 * x6 * (2.0 * x0 * x11 * x17 * x18 * x5 * x6 - x16) + x120 * x5
x122 = x117 * x6 * (2.0 * x0 * x11 * x17 * x29 * x6 - x31)
x123 = 0.5 * x122
x124 = x117 * x34 + x123
x125 = x124 * x39
x126 = x117 * x6 * (2.0 * x0 * x11 * x17 * x6 * x9 - x42)
x127 = 0.5 * x126
x128 = x117 * x47 + x127
x129 = x117 * x6 * (2.0 * x0 * x11 * x17 * x5 * x6 * x9 - x43) + x128 * x5
x130 = x120 * x39
x131 = x117 * x6 * (2.0 * x0 * x11 * x17 * x22 * x6 - x53)
x132 = 0.5 * x131
x133 = x117 * x6 * (2.0 * x0 * x11 * x17 * x22 * x5 * x6 - x54) + x5 * (
x117 * x57 + x132
)
x134 = x133 * x4
x135 = x128 * x39
x136 = 3.0 * x135
x137 = x129 * x52
x138 = x63 * (x121 - x137)
x139 = x128 * x4
x140 = x117 * x22
x141 = x140 * x5
x142 = x106 * x141
x143 = x139 + x142
x144 = x63 * (-x120 * x52 + x124)
x145 = x111 * x117
x146 = x117 * x25
x147 = x79**2
x148 = x147 * x25 + x20
x149 = x147 * x33 + x32
x150 = x147 * x36 - x149 * x7 + x30
x151 = x148 * x21 + x150 * x19
x152 = x147 * x24
x153 = x152 * x45
x154 = x153 + x44
x155 = -x148 * x7 + x149
x156 = x154 * x21 + x155 * x19
x157 = x148 * x39
x158 = x157 * x5
x159 = x149 * x5
x160 = x152 * x56
x161 = x160 + x55
x162 = x148 - x154 * x7
x163 = x161 * x21 + x162 * x19
x164 = x163 * x4
x165 = x154 * x5
x166 = x110 * x165
x167 = x156 * x52
x168 = x63 * (x151 - x167)
x169 = x113 * x154
x170 = x157 + x169
x171 = x5 * x52
x172 = x63 * (-x148 * x171 + x149 * x5)
x173 = 3.872983346207417
x174 = 0.02222222222222222 * x173 * x75
x175 = x117 * x6 * (2.0 * x0 * x11 * x17 * x18 * x6 * x79 - x81)
x176 = x117 * x83 + 0.5 * x175
x177 = x117 * x6 * (2.0 * x0 * x11 * x17 * x6 * x79 * x9 - x89)
x178 = x117 * x91 + 0.5 * x177
x179 = x105 * x117
x180 = x106 * x179
x181 = x69 * x72
x182 = x117 * x181
x183 = x182 * x80
x184 = x117 * x6 * (2.0 * x0 * x11 * x17 * x22 * x6 * x79 - x95)
x185 = x117 * x97 + 0.5 * x184
x186 = x117 * x45
x187 = x106 * x186 * x80
x188 = x63 * (x176 - x178 * x52)
x189 = x110 * x71
x190 = x140 * x79
x191 = x189 * x190
x192 = x186 * x24 * x79
x193 = x113 * x192 + x191
x194 = 2.0 * x0 * x11 * x63 * (-x10 * x179 + x117 * x17 * x5 * x6 * x79 * x9)
x195 = 2.23606797749979 * x115
x196 = x117**2
x197 = x196 * x25 + x20
x198 = x196 * x33 + x32
x199 = x196 * x36 - x198 * x7 + x30
x200 = x19 * x199
x201 = x197 * x21 + x200
x202 = x196 * x24
x203 = x202 * x45 + x44
x204 = -x197 * x7 + x198
x205 = x19 * x204
x206 = x203 * x21 + x205
x207 = x197 * x39
x208 = x207 * x5
x209 = x198 * x5
x210 = x202 * x56 + x55
x211 = x197 - x203 * x7
x212 = x19 * x211
x213 = x21 * x210 + x212
x214 = x213 * x4
x215 = x203 * x5
x216 = x206 * x52
x217 = x63 * (x201 - x216)
x218 = x113 * x203
x219 = x207 + x218
x220 = x197 * x5
x221 = x63 * (x198 * x5 - x220 * x52)
x222 = x149 * x79 + x86
x223 = x222 * x39
x224 = x148 * x79 + x82
x225 = x224 * x5
x226 = x224 * x39
x227 = x154 * x79 + x90
x228 = x4**2
x229 = x63 * (x222 - x224 * x52)
x230 = x227 * x39
x231 = x161 * x79 + x96
x232 = x113 * x231
x233 = x63 * (-x171 * x227 + x224 * x5)
x234 = x230 * x4
x235 = x117 * x147 * x33 + x123
x236 = x235 * x39
x237 = x119 + x146 * x147
x238 = x237 * x5
x239 = x237 * x39
x240 = x117 * x153 + x127
x241 = x63 * (x235 - x237 * x52)
x242 = x240 * x39
x243 = x117 * x160 + x132
x244 = x63 * (-x171 * x240 + x237 * x5)
x245 = x198 * x79
x246 = x207 * x79
x247 = x197 * x79
x248 = x63 * (x198 * x79 - x247 * x52)
x249 = x203 * x79
x250 = x249 * x39
x251 = x210 * x79
x252 = x63 * (-x171 * x249 + x197 * x5 * x79)
x253 = x117 * x198 + x122
x254 = x253 * x39
x255 = x117 * x197 + x118
x256 = x255 * x5
x257 = x255 * x39
x258 = x117 * x203 + x126
x259 = x63 * (x253 - x255 * x52)
x260 = x258 * x39
x261 = x117 * x210 + x131
x262 = x113 * x261
x263 = x63 * (-x171 * x258 + x255 * x5)
x264 = x260 * x4
x265 = x150 * x37 + x224 * x79
x266 = x155 * x37 + x227 * x79
x267 = x266 * x52
x268 = x162 * x37 + x231 * x79
x269 = x228 * x268
x270 = x63 * (x265 - x267)
x271 = x175 + x237 * x79
x272 = x177 + x240 * x79
x273 = x272 * x52
x274 = x184 + x243 * x79
x275 = x63 * (x271 - x273)
x276 = x147 * x197 + x200
x277 = x147 * x203 + x205
x278 = x277 * x52
x279 = x147 * x210 + x212
x280 = x63 * (x276 - x278)
x281 = x258 * x79
x282 = x281 * x52
x283 = x63 * (x255 * x79 - x282)
x284 = x261 * x79
x285 = x117 * x255 + x199 * x37
x286 = x117 * x258 + x204 * x37
x287 = x286 * x52
x288 = x117 * x261 + x211 * x37
x289 = x228 * x288
x290 = x63 * (x285 - x287)
x291 = -x78 - A[1]
x292 = x291 * x59
x293 = x291 * x61
x294 = x0 * x291 * (x38 - x62)
x295 = 5.916079783099616 * x76
x296 = x291 * x98
x297 = x296 + x60
x298 = x291 * x92
x299 = x298 + x66
x300 = x0 * (x291 * x85 + x41 - x52 * (x291 * x93 + x51))
x301 = x110 * x73
x302 = x291 * x5
x303 = x110 * (x114 * x302 + x301)
x304 = x0 * x291 * (x121 - x137)
x305 = x140 * x302
x306 = x163 * x291
x307 = 2.0 * x100
x308 = x306 + x307
x309 = x154 * x302
x310 = x107 + x309
x311 = x0 * (x151 * x291 - x52 * (x156 * x291 + 2.0 * x94) + 2.0 * x88)
x312 = x39 * (x148 * x291 + x181 * x79)
x313 = 1.732050807568877
x314 = 0.1111111111111111 * x313 * x75
x315 = x135 + x185 * x291
x316 = x141 * x189 + x192 * x302
x317 = x110 * x316
x318 = x0 * (x125 + x176 * x291 - x52 * (x130 + x178 * x291))
x319 = x114 * x117
x320 = x39 * (x145 + x291 * x319)
x321 = 0.3333333333333333 * x75
x322 = x203 * x302
x323 = x0 * x291 * (x201 - x216)
x324 = x207 * x291
x325 = x227 * x291
x326 = 3.0 * x157
x327 = x325 + x326
x328 = x327 * x39
x329 = x231 * x302
x330 = x165 * x74
x331 = x329 + x330
x332 = x0 * (x159 * x74 + x225 * x291 - x5 * x52 * (x325 + x326))
x333 = x240 * x291
x334 = x106 * x190
x335 = x333 + x334
x336 = x335 * x39
x337 = x187 + x243 * x302
x338 = x0 * (x183 + x238 * x291 - x52 * (x180 + x333 * x5))
x339 = x207 + x249 * x291
x340 = x339 * x39
x341 = x215 * x39 + x251 * x302
x342 = x0 * (x209 * x39 + x220 * x291 * x79 - x52 * (x208 + x249 * x302))
x343 = x260 * x291
x344 = x0 * (x255 * x291 * x5 - x258 * x302 * x52)
x345 = x268 * x291
x346 = 4.0 * x230
x347 = x345 + x346
x348 = x0 * (4.0 * x223 + x265 * x291 - x52 * (4.0 * x226 + x266 * x291))
x349 = 3.0 * x242 + x274 * x291
x350 = x0 * (3.0 * x236 + x271 * x291 - x52 * (3.0 * x239 + x272 * x291))
x351 = x110 * x249 + x279 * x291
x352 = x0 * (x110 * x245 + x276 * x291 - x52 * (2.0 * x246 + x277 * x291))
x353 = x260 + x284 * x291
x354 = x255 * x79
x355 = x0 * (x254 + x291 * x354 - x52 * (x257 + x281 * x291))
x356 = x0 * x291 * (x285 - x287)
x357 = -x116 - A[2]
x358 = x0 * x357 * (x38 - x62)
x359 = 0.5 * x358
x360 = x0 * x357 * (-x102 + x85)
x361 = 0.5 * x360
x362 = x357 * x5
x363 = x22 * x362 * x79
x364 = x106 * x363
x365 = x133 * x357 + x60
x366 = x365 * x4
x367 = x128 * x357 + x66
x368 = x367 * x39
x369 = 3.0 * x368
x370 = x0 * (x121 * x357 + x41 - x52 * (x129 * x357 + x51))
x371 = 0.5 * x370
x372 = x39 * (x146 * x362 + x301)
x373 = 2.0 * x372
x374 = x0 * x357 * (x151 - x167)
x375 = 0.5 * x374
x376 = x157 * x357
x377 = x100 + x185 * x357
x378 = x105 * x189 + x192 * x362
x379 = x110 * x378
x380 = x0 * (x176 * x357 - x52 * (x178 * x357 + x94) + x88)
x381 = 0.5 * x380
x382 = x39 * (x112 + x319 * x357)
x383 = 2.0 * x135 + x213 * x357
x384 = x383 * x4
x385 = x142 + x215 * x357
x386 = x385 * x39
x387 = 2.0 * x386
x388 = x0 * (2.0 * x125 + x201 * x357 - x52 * (2.0 * x130 + x206 * x357))
x389 = 0.5 * x388
x390 = x197 * x357
x391 = x39 * (x182 + x390)
x392 = x230 * x357
x393 = x0 * (x224 * x357 * x5 - x227 * x362 * x52)
x394 = 0.5 * x393
x395 = x240 * x357
x396 = x157 + x395
x397 = x39 * x396
x398 = x165 * x39
x399 = x243 * x362 + x398
x400 = x0 * (x159 * x39 + x238 * x357 - x52 * (x158 + x395 * x5))
x401 = 0.5 * x400
x402 = x249 * x357 + x334
x403 = x39 * x402
x404 = x187 + x251 * x362
x405 = x0 * (x183 + x390 * x80 - x52 * (x180 + x249 * x362))
x406 = 0.5 * x405
x407 = x258 * x357
x408 = 3.0 * x207 + x407
x409 = x39 * x408
x410 = x215 * x74 + x261 * x362
x411 = x4 * x410
x412 = x0 * (x209 * x74 + x256 * x357 - x52 * (3.0 * x208 + x407 * x5))
x413 = 0.5 * x412
x414 = x0 * x357 * (x265 - x267)
x415 = 0.5 * x414
x416 = x230 + x274 * x357
x417 = x0 * (x223 + x271 * x357 - x52 * (x226 + x272 * x357))
x418 = 0.5 * x417
x419 = 2.0 * x242 + x279 * x357
x420 = x0 * (2.0 * x236 + x276 * x357 - x52 * (2.0 * x239 + x277 * x357))
x421 = 0.5 * x420
x422 = x249 * x74 + x284 * x357
x423 = x0 * (x245 * x74 + x354 * x357 - x52 * (3.0 * x246 + x407 * x79))
x424 = 0.5 * x423
x425 = 4.0 * x260 + x288 * x357
x426 = x0 * (4.0 * x254 + x285 * x357 - x52 * (4.0 * x257 + x286 * x357))
x427 = 0.5 * x426
x428 = x291**2
x429 = x428 * x58
x430 = x429 + x64
x431 = x39 * (x428 * x49 + x70)
x432 = x291 * x60
x433 = x103 + x291 * x297 + x432
x434 = x109 + x291 * x299 + x291 * x66
x435 = x133 * x428 + x138
x436 = x39 * (x128 * x428 + x144)
x437 = x110 * x299 + x168 + x291 * x308
x438 = x172 + x291 * x310 + x303
x439 = x135 * x291 + x188 + x291 * x315
x440 = x110 * (x189 * x305 + x194 + x291 * x316)
x441 = x213 * x428 + x217
x442 = x39 * (x215 * x428 + x221)
x443 = x39 * (x229 + x291 * x327 + 3.0 * x312)
x444 = x233 + x291 * x331 + x310 * x74
x445 = x39 * (x241 + x291 * x335 + 2.0 * x320)
x446 = x244 + x291 * x337 + x317
x447 = x39 * (x248 + x291 * x339 + x324)
x448 = x252 + x291 * x341 + x322 * x39
x449 = x39 * (x258 * x428 + x259)
x450 = x261 * x428 * x5 + x263
x451 = x270 + x291 * x347 + 4.0 * x328
x452 = x295 * x4
x453 = x275 + x291 * x349 + 3.0 * x336
x454 = x195 * x4
x455 = x280 + x291 * x351 + 2.0 * x340
x456 = x314 * x4
x457 = x283 + x291 * x353 + x343
x458 = x288 * x428 + x290
x459 = 10.2469507659596 * x76
x460 = x357 * x60
x461 = x296 * x357 + x460
x462 = x357 * x66
x463 = x298 * x357 + x462
x464 = x115 * x173
x465 = x357 * (x306 + x307)
x466 = x309 * x357 + x364
x467 = x291 * x377 + x368
x468 = x110 * (x291 * x378 + x372)
x469 = x313 * x321
x470 = x357 * x39 * (x325 + x326)
x471 = x357 * (x329 + x330)
x472 = 2.0 * x382
x473 = x39 * (x291 * x396 + x472)
x474 = x291 * x399 + x379
x475 = x39 * (x291 * x402 + x391)
x476 = x291 * x404 + x386
x477 = x291 * x409
x478 = x357 * (x345 + x346)
x479 = x4 * x459
x480 = x291 * x416 + 3.0 * x397
x481 = x4 * x464
x482 = x291 * x419 + 2.0 * x403
x483 = x291 * x422 + x409
x484 = x357**2
x485 = x484 * x58 + x64
x486 = x39 * (x484 * x49 + x70)
x487 = x103 + x484 * x98
x488 = x39 * (x109 + x484 * x92)
x489 = x138 + x357 * x365 + x460
x490 = x39 * (x144 + x357 * x367 + x462)
x491 = x163 * x484 + x168
x492 = x39 * (x165 * x484 + x172)
x493 = x100 * x357 + x188 + x357 * x377
x494 = x110 * (x189 * x363 + x194 + x357 * x378)
x495 = x217 + x357 * x383 + 2.0 * x368
x496 = x39 * (x221 + x357 * x385 + x373)
x497 = x39 * (x227 * x484 + x229)
x498 = x231 * x484 * x5 + x233
x499 = x39 * (x241 + x357 * x396 + x376)
x500 = x244 + x357 * x398 + x357 * x399
x501 = x39 * (x248 + x357 * x402 + x472)
x502 = x252 + x357 * x404 + x379
x503 = x39 * (x259 + x357 * x408 + 3.0 * x391)
x504 = x263 + x357 * x410 + 3.0 * x386
x505 = x268 * x484 + x270
x506 = x275 + x357 * x416 + x392
x507 = x280 + x357 * x419 + 2.0 * x397
x508 = x283 + x357 * x422 + 3.0 * x403
x509 = x290 + x357 * x425 + 4.0 * x409
x510 = x291 * x295
x511 = x195 * x291
# 150 item(s)
result[0, 0] = numpy.sum(
x77
* (
x0 * (x38 * x4 + 4.0 * x41 - x52 * (x4 * x50 + 4.0 * x51))
+ x4 * (x4 * (x59 + x61) + x64 + x68 * x69)
+ x69 * (x4 * x68 + x70 + x74 * (x27 * x4 + x69 * x73))
)
)
result[0, 1] = numpy.sum(
x115
* (
x0 * (x4 * x85 - x52 * (x4 * x93 + 3.0 * x94) + 3.0 * x88)
+ x4 * (x103 + x108 * x74 + x4 * (x101 + x99))
+ x74 * (x108 * x4 + x109 + x110 * (x112 + x113 * x114))
)
)
result[0, 2] = numpy.sum(
x115
* (
x0 * (x121 * x4 + 3.0 * x125 - x52 * (x129 * x4 + 3.0 * x130))
+ x4 * (x138 + x143 * x74 + x4 * (x134 + x136))
+ x74 * (x110 * (x113 * x146 + x145) + x143 * x4 + x144)
)
)
result[0, 3] = numpy.sum(
x174
* (
x0 * (x110 * x159 + x151 * x4 - x52 * (x156 * x4 + 2.0 * x158))
+ x110 * (x157 * x4 + x170 * x4 + x172)
+ x4 * (x110 * x170 + x168 + x4 * (x164 + x166))
)
)
result[0, 4] = numpy.sum(
x195
* (
x0 * (x176 * x4 + x183 - x52 * (x178 * x4 + x180))
+ x110 * (x191 * x4 + x193 * x4 + x194)
+ x4 * (x110 * x193 + x188 + x4 * (x185 * x4 + x187))
)
)
result[0, 5] = numpy.sum(
x174
* (
x0 * (x110 * x209 + x201 * x4 - x52 * (x206 * x4 + 2.0 * x208))
+ x110 * (x207 * x4 + x219 * x4 + x221)
+ x4 * (x110 * x219 + x217 + x4 * (x110 * x215 + x214))
)
)
result[0, 6] = numpy.sum(
x115
* (
x0 * (x223 + x225 * x4 - x52 * (x113 * x227 + x226))
+ x39 * (x227 * x228 + x229)
+ x4 * (x233 + x234 + x4 * (x230 + x232))
)
)
result[0, 7] = numpy.sum(
x195
* (
x0 * (x236 + x238 * x4 - x52 * (x113 * x240 + x239))
+ x39 * (x228 * x240 + x241)
+ x4 * (x242 * x4 + x244 + x4 * (x113 * x243 + x242))
)
)
result[0, 8] = numpy.sum(
x195
* (
x0 * (x113 * x247 + x245 * x39 - x52 * (x218 * x79 + x246))
+ x39 * (x228 * x249 + x248)
+ x4 * (x250 * x4 + x252 + x4 * (x113 * x251 + x250))
)
)
result[0, 9] = numpy.sum(
x115
* (
x0 * (x254 + x256 * x4 - x52 * (x113 * x258 + x257))
+ x39 * (x228 * x258 + x259)
+ x4 * (x263 + x264 + x4 * (x260 + x262))
)
)
result[0, 10] = numpy.sum(x4 * x77 * (x0 * (x265 - x267) + x269 + x270))
result[0, 11] = numpy.sum(x115 * x4 * (x0 * (x271 - x273) + x228 * x274 + x275))
result[0, 12] = numpy.sum(x174 * x4 * (x0 * (x276 - x278) + x228 * x279 + x280))
result[0, 13] = numpy.sum(x115 * x4 * (x0 * (x255 * x79 - x282) + x228 * x284 + x283))
result[0, 14] = numpy.sum(x4 * x77 * (x0 * (x285 - x287) + x289 + x290))
result[1, 0] = numpy.sum(
0.5 * x295 * (2.0 * x291 * x69 * (x65 + x67) + x294 + 2.0 * x4 * (x292 + x293))
)
result[1, 1] = numpy.sum(
0.5
* x195
* (x300 + 2.0 * x4 * (x297 * x4 + x299 * x74) + 2.0 * x74 * (x299 * x4 + x303))
)
result[1, 2] = numpy.sum(
0.5
* x195
* (
2.0 * x291 * x4 * (x134 + x136)
+ x304
+ 2.0 * x74 * (x106 * x305 + x139 * x291)
)
)
result[1, 3] = numpy.sum(
0.5
* x314
* (2.0 * x110 * (x310 * x4 + x312) + x311 + 2.0 * x4 * (x110 * x310 + x308 * x4))
)
result[1, 4] = numpy.sum(
0.5
* x321
* (2.0 * x110 * (x316 * x4 + x320) + x318 + 2.0 * x4 * (x315 * x4 + x317))
)
result[1, 5] = numpy.sum(
0.5
* x314
* (
2.0 * x110 * (x218 * x291 + x324)
+ x323
+ 2.0 * x4 * (x110 * x322 + x214 * x291)
)
)
result[1, 6] = numpy.sum(0.5 * x195 * (4.0 * x328 * x4 + 2.0 * x331 * x4**2 + x332))
result[1, 7] = numpy.sum(0.5 * x321 * (4.0 * x336 * x4 + 2.0 * x337 * x4**2 + x338))
result[1, 8] = numpy.sum(0.5 * x321 * (4.0 * x340 * x4 + 2.0 * x341 * x4**2 + x342))
result[1, 9] = numpy.sum(
0.5 * x195 * (2.0 * x264 * x291 + x344 + 2.0 * x4 * (x262 * x291 + x343))
)
result[1, 10] = numpy.sum(0.5 * x295 * (2.0 * x228 * x347 + x348))
result[1, 11] = numpy.sum(0.5 * x195 * (2.0 * x228 * x349 + x350))
result[1, 12] = numpy.sum(0.5 * x314 * (2.0 * x228 * x351 + x352))
result[1, 13] = numpy.sum(0.5 * x195 * (2.0 * x228 * x353 + x355))
result[1, 14] = numpy.sum(0.5 * x295 * (2.0 * x289 * x291 + x356))
result[2, 0] = numpy.sum(
x295 * (x357 * x4 * (x59 + x61) + x357 * x69 * (x65 + x67) + x359)
)
result[2, 1] = numpy.sum(
x195 * (x357 * x4 * (x101 + x99) + x361 + x74 * (x104 * x357 + x364))
)
result[2, 2] = numpy.sum(
x195 * (x371 + x4 * (x366 + x369) + x74 * (x367 * x4 + x373))
)
result[2, 3] = numpy.sum(
x314 * (x110 * (x169 * x357 + x376) + x357 * x4 * (x164 + x166) + x375)
)
result[2, 4] = numpy.sum(
x321 * (x110 * (x378 * x4 + x382) + x381 + x4 * (x377 * x4 + x379))
)
result[2, 5] = numpy.sum(
x314 * (x110 * (x385 * x4 + x391) + x389 + x4 * (x384 + x387))
)
result[2, 6] = numpy.sum(x195 * (x234 * x357 + x394 + x4 * (x232 * x357 + x392)))
result[2, 7] = numpy.sum(x321 * (x397 * x4 + x4 * (x397 + x399 * x4) + x401))
result[2, 8] = numpy.sum(x321 * (x4 * x403 + x4 * (x4 * x404 + x403) + x406))
result[2, 9] = numpy.sum(x195 * (x4 * x409 + x4 * (x409 + x411) + x413))
result[2, 10] = numpy.sum(x295 * (x269 * x357 + x415))
result[2, 11] = numpy.sum(x195 * (x228 * x416 + x418))
result[2, 12] = numpy.sum(x314 * (x228 * x419 + x421))
result[2, 13] = numpy.sum(x195 * (x228 * x422 + x424))
result[2, 14] = numpy.sum(x295 * (x228 * x425 + x427))
result[3, 0] = numpy.sum(x295 * (x4 * x430 + 4.0 * x431))
result[3, 1] = numpy.sum(x195 * (x4 * x433 + x434 * x74))
result[3, 2] = numpy.sum(x195 * (x4 * x435 + 3.0 * x436))
result[3, 3] = numpy.sum(x314 * (x110 * x438 + x4 * x437))
result[3, 4] = numpy.sum(x321 * (x4 * x439 + x440))
result[3, 5] = numpy.sum(x314 * (x4 * x441 + 2.0 * x442))
result[3, 6] = numpy.sum(x195 * (x4 * x444 + x443))
result[3, 7] = numpy.sum(x321 * (x4 * x446 + x445))
result[3, 8] = numpy.sum(x321 * (x4 * x448 + x447))
result[3, 9] = numpy.sum(x195 * (x4 * x450 + x449))
result[3, 10] = numpy.sum(x451 * x452)
result[3, 11] = numpy.sum(x453 * x454)
result[3, 12] = numpy.sum(x455 * x456)
result[3, 13] = numpy.sum(x454 * x457)
result[3, 14] = numpy.sum(x452 * x458)
result[4, 0] = numpy.sum(x357 * x459 * (x292 + x293))
result[4, 1] = numpy.sum(x464 * (x4 * x461 + x463 * x74))
result[4, 2] = numpy.sum(x291 * x464 * (x366 + x369))
result[4, 3] = numpy.sum(x321 * (x110 * x466 + x4 * x465))
result[4, 4] = numpy.sum(x469 * (x4 * x467 + x468))
result[4, 5] = numpy.sum(x291 * x321 * (x384 + x387))
result[4, 6] = numpy.sum(x464 * (x4 * x471 + x470))
result[4, 7] = numpy.sum(x469 * (x4 * x474 + x473))
result[4, 8] = numpy.sum(x469 * (x4 * x476 + x475))
result[4, 9] = numpy.sum(x464 * (x291 * x411 + x477))
result[4, 10] = numpy.sum(x478 * x479)
result[4, 11] = numpy.sum(x480 * x481)
result[4, 12] = numpy.sum(x321 * x4 * x482)
result[4, 13] = numpy.sum(x481 * x483)
result[4, 14] = numpy.sum(x291 * x425 * x479)
result[5, 0] = numpy.sum(x295 * (x4 * x485 + 4.0 * x486))
result[5, 1] = numpy.sum(x195 * (x4 * x487 + 3.0 * x488))
result[5, 2] = numpy.sum(x195 * (x4 * x489 + 3.0 * x490))
result[5, 3] = numpy.sum(x314 * (x4 * x491 + 2.0 * x492))
result[5, 4] = numpy.sum(x321 * (x4 * x493 + x494))
result[5, 5] = numpy.sum(x314 * (x4 * x495 + 2.0 * x496))
result[5, 6] = numpy.sum(x195 * (x4 * x498 + x497))
result[5, 7] = numpy.sum(x321 * (x4 * x500 + x499))
result[5, 8] = numpy.sum(x321 * (x4 * x502 + x501))
result[5, 9] = numpy.sum(x195 * (x4 * x504 + x503))
result[5, 10] = numpy.sum(x452 * x505)
result[5, 11] = numpy.sum(x454 * x506)
result[5, 12] = numpy.sum(x456 * x507)
result[5, 13] = numpy.sum(x454 * x508)
result[5, 14] = numpy.sum(x452 * x509)
result[6, 0] = numpy.sum(x77 * (x291 * x430 + x294))
result[6, 1] = numpy.sum(x115 * (x291 * x433 + x300 + x431))
result[6, 2] = numpy.sum(x115 * (x291 * x435 + x304))
result[6, 3] = numpy.sum(x174 * (x110 * x434 + x291 * x437 + x311))
result[6, 4] = numpy.sum(x195 * (x291 * x439 + x318 + x436))
result[6, 5] = numpy.sum(x174 * (x291 * x441 + x323))
result[6, 6] = numpy.sum(x115 * (x291 * x444 + x332 + x438 * x74))
result[6, 7] = numpy.sum(x195 * (x291 * x446 + x338 + x440))
result[6, 8] = numpy.sum(x195 * (x291 * x448 + x342 + x442))
result[6, 9] = numpy.sum(x115 * (x291 * x450 + x344))
result[6, 10] = numpy.sum(x77 * (x291 * x451 + x348 + 4.0 * x443))
result[6, 11] = numpy.sum(x115 * (x291 * x453 + x350 + 3.0 * x445))
result[6, 12] = numpy.sum(x174 * (x291 * x455 + x352 + 2.0 * x447))
result[6, 13] = numpy.sum(x115 * (x291 * x457 + x355 + x449))
result[6, 14] = numpy.sum(x77 * (x291 * x458 + x356))
result[7, 0] = numpy.sum(x295 * (x357 * x429 + x359))
result[7, 1] = numpy.sum(x195 * (x291 * x461 + x357 * x432 + x361))
result[7, 2] = numpy.sum(x195 * (x365 * x428 + x371))
result[7, 3] = numpy.sum(x314 * (x110 * x463 + x291 * x465 + x375))
result[7, 4] = numpy.sum(x321 * (x291 * x368 + x291 * x467 + x381))
result[7, 5] = numpy.sum(x314 * (x383 * x428 + x389))
result[7, 6] = numpy.sum(x195 * (x291 * x471 + x394 + x466 * x74))
result[7, 7] = numpy.sum(x321 * (x291 * x474 + x401 + x468))
result[7, 8] = numpy.sum(x321 * (x291 * x386 + x291 * x476 + x406))
result[7, 9] = numpy.sum(x195 * (x410 * x428 + x413))
result[7, 10] = numpy.sum(x295 * (x291 * x478 + x415 + 4.0 * x470))
result[7, 11] = numpy.sum(x195 * (x291 * x480 + x418 + 3.0 * x473))
result[7, 12] = numpy.sum(x314 * (x291 * x482 + x421 + 2.0 * x475))
result[7, 13] = numpy.sum(x195 * (x291 * x483 + x424 + x477))
result[7, 14] = numpy.sum(x295 * (x425 * x428 + x427))
result[8, 0] = numpy.sum(x485 * x510)
result[8, 1] = numpy.sum(x195 * (x291 * x487 + x486))
result[8, 2] = numpy.sum(x489 * x511)
result[8, 3] = numpy.sum(x314 * (x291 * x491 + 2.0 * x488))
result[8, 4] = numpy.sum(x321 * (x291 * x493 + x490))
result[8, 5] = numpy.sum(x291 * x314 * x495)
result[8, 6] = numpy.sum(x195 * (x291 * x498 + 3.0 * x492))
result[8, 7] = numpy.sum(x321 * (x291 * x500 + x494))
result[8, 8] = numpy.sum(x321 * (x291 * x502 + x496))
result[8, 9] = numpy.sum(x504 * x511)
result[8, 10] = numpy.sum(x295 * (x291 * x505 + 4.0 * x497))
result[8, 11] = numpy.sum(x195 * (x291 * x506 + 3.0 * x499))
result[8, 12] = numpy.sum(x314 * (x291 * x507 + 2.0 * x501))
result[8, 13] = numpy.sum(x195 * (x291 * x508 + x503))
result[8, 14] = numpy.sum(x509 * x510)
result[9, 0] = numpy.sum(x77 * (x357 * x485 + x358))
result[9, 1] = numpy.sum(x115 * (x357 * x487 + x360))
result[9, 2] = numpy.sum(x115 * (x357 * x489 + x370 + x486))
result[9, 3] = numpy.sum(x174 * (x357 * x491 + x374))
result[9, 4] = numpy.sum(x195 * (x357 * x493 + x380 + x488))
result[9, 5] = numpy.sum(x174 * (x357 * x495 + x388 + 2.0 * x490))
result[9, 6] = numpy.sum(x115 * (x357 * x498 + x393))
result[9, 7] = numpy.sum(x195 * (x357 * x500 + x400 + x492))
result[9, 8] = numpy.sum(x195 * (x357 * x502 + x405 + x494))
result[9, 9] = numpy.sum(x115 * (x357 * x504 + x412 + 3.0 * x496))
result[9, 10] = numpy.sum(x77 * (x357 * x505 + x414))
result[9, 11] = numpy.sum(x115 * (x357 * x506 + x417 + x497))
result[9, 12] = numpy.sum(x174 * (x357 * x507 + x420 + 2.0 * x499))
result[9, 13] = numpy.sum(x115 * (x357 * x508 + x423 + 3.0 * x501))
result[9, 14] = numpy.sum(x77 * (x357 * x509 + x426 + 4.0 * x503))
return result
[docs]
def int2c2e3d_40(ax, da, A, bx, db, B):
"""Cartesian (g|s) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((15, 1), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = x1 * (ax * A[0] + bx * B[0]) - A[0]
x3 = ax ** (-1.0)
x4 = bx * x1
x5 = ax * x4 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x6 = boys(3, x5)
x7 = 17.49341832762486
x8 = 2.0 * x3 * x7
x9 = x0 ** (-1.5) * x8
x10 = x6 * x9
x11 = x10 * x2
x12 = bx ** (-1.0)
x13 = x0 ** (-0.5)
x14 = boys(2, x5)
x15 = 0.5 * x3
x16 = x15 * (-x10 + 2.0 * x12 * x13 * x14 * x3 * x7)
x17 = boys(4, x5)
x18 = x2**2
x19 = x12 * x13 * x8
x20 = x18 * x19
x21 = x17 * x20
x22 = boys(1, x5)
x23 = x15 * (2.0 * x12 * x13 * x3 * x7 * boys(0, x5) - x22 * x9)
x24 = x15 * (2.0 * x12 * x13 * x22 * x3 * x7 - x14 * x9)
x25 = x14 * x19
x26 = 1.5 * x3
x27 = da * db
x28 = 0.09759000729485332 * x27
x29 = x1 * (ax * A[1] + bx * B[1]) - A[1]
x30 = x10 * x29
x31 = x3 * (2.0 * x12 * x13 * x14 * x29 * x3 * x7 - x30)
x32 = x21 * x29
x33 = 0.2581988897471611 * x27
x34 = x1 * (ax * A[2] + bx * B[2]) - A[2]
x35 = x3 * x34 * (-x10 + 2.0 * x12 * x13 * x14 * x3 * x7)
x36 = 0.5 * x35
x37 = x29**2
x38 = x19 * x37
x39 = x17 * x38
x40 = x16 + x39
x41 = x23 + x25 * x37 - x4 * (x24 + x38 * x6)
x42 = 0.3333333333333333 * x27
x43 = x3 * x34 * (2.0 * x12 * x13 * x14 * x29 * x3 * x7 - x30)
x44 = 1.732050807568877 * x42
x45 = x34**2
x46 = x19 * x45
x47 = x16 + x17 * x46
x48 = x23 + x25 * x45 - x4 * (x24 + x46 * x6)
x49 = x15 * x48
x50 = x29 * x40 + x31
x51 = x2 * x33
x52 = x34 * x39 + x36
x53 = x2 * x44
x54 = x34 * x47 + x35
# 15 item(s)
result[0, 0] = numpy.sum(
x28
* (
x2 * (x2 * (x16 + x21) - x3 * (x11 - 2.0 * x12 * x13 * x14 * x2 * x3 * x7))
+ x26 * (x18 * x25 + x23 - x4 * (x20 * x6 + x24))
)
)
result[1, 0] = numpy.sum(
0.5
* x33
* (
x2 * (x31 + 2.0 * x32)
- 2.0 * x29 * x3 * (x11 - 2.0 * x12 * x13 * x14 * x2 * x3 * x7)
)
)
result[2, 0] = numpy.sum(
x33
* (
x2 * (x21 * x34 + x36)
- x3 * x34 * (x11 - 2.0 * x12 * x13 * x14 * x2 * x3 * x7)
)
)
result[3, 0] = numpy.sum(x42 * (x15 * x41 + x18 * x40))
result[4, 0] = numpy.sum(0.5 * x44 * (2.0 * x32 * x34 + x43))
result[5, 0] = numpy.sum(x42 * (x18 * x47 + x49))
result[6, 0] = numpy.sum(x50 * x51)
result[7, 0] = numpy.sum(x52 * x53)
result[8, 0] = numpy.sum(x29 * x47 * x53)
result[9, 0] = numpy.sum(x51 * x54)
result[10, 0] = numpy.sum(x28 * (x26 * x41 + x29 * x50))
result[11, 0] = numpy.sum(x33 * (x29 * x52 + x43))
result[12, 0] = numpy.sum(x42 * (x37 * x47 + x49))
result[13, 0] = numpy.sum(x29 * x33 * x54)
result[14, 0] = numpy.sum(x28 * (x26 * x48 + x34 * x54))
return result
[docs]
def int2c2e3d_41(ax, da, A, bx, db, B):
"""Cartesian (g|p) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((15, 3), dtype=float)
x0 = 0.5 / (ax + bx)
x1 = ax ** (-1.0)
x2 = ax + bx
x3 = x2 ** (-1.0)
x4 = -x3 * (ax * A[0] + bx * B[0])
x5 = -x4 - A[0]
x6 = bx * x3
x7 = ax * x6 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x8 = boys(3, x7)
x9 = 17.49341832762486
x10 = 2.0 * x1 * x9
x11 = x10 * x2 ** (-1.5)
x12 = x11 * x8
x13 = bx ** (-1.0)
x14 = x2 ** (-0.5)
x15 = boys(2, x7)
x16 = 0.5 * x1
x17 = x16 * (2.0 * x1 * x13 * x14 * x15 * x9 - x12)
x18 = x5**2
x19 = boys(4, x7)
x20 = x10 * x13 * x14
x21 = x19 * x20
x22 = x18 * x21
x23 = x17 + x22
x24 = x20 * x8
x25 = x0 * x24
x26 = -x4 - B[0]
x27 = x26 * x5
x28 = x21 * x27
x29 = x25 + x28
x30 = x15 * x20
x31 = x0 * x30
x32 = x24 * x26
x33 = x32 * x5
x34 = x31 + x33
x35 = x0 * x21
x36 = x20 * boys(5, x7)
x37 = x27 * x36
x38 = x11 * x26
x39 = x19 * x38
x40 = x16 * (2.0 * x1 * x13 * x14 * x26 * x8 * x9 - x39)
x41 = x35 * x5
x42 = boys(1, x7)
x43 = x16 * (2.0 * x1 * x13 * x14 * x26 * x42 * x9 - x15 * x38)
x44 = x16 * x26 * (2.0 * x1 * x13 * x14 * x15 * x9 - x12)
x45 = 1.5 * x1
x46 = da * db
x47 = 0.09759000729485332 * x46
x48 = -x3 * (ax * A[1] + bx * B[1])
x49 = -x48 - B[1]
x50 = x11 * x49
x51 = x19 * x50
x52 = x5 * x51
x53 = x16 * (2.0 * x1 * x13 * x14 * x49 * x8 * x9 - x51)
x54 = x18 * x36
x55 = x49 * x54
x56 = x16 * (2.0 * x1 * x13 * x14 * x42 * x49 * x9 - x15 * x50)
x57 = x16 * x49 * (2.0 * x1 * x13 * x14 * x15 * x9 - x12)
x58 = x24 * x49
x59 = -x3 * (ax * A[2] + bx * B[2])
x60 = -x59 - B[2]
x61 = x11 * x60
x62 = x19 * x61
x63 = x5 * x62
x64 = x16 * (2.0 * x1 * x13 * x14 * x60 * x8 * x9 - x62)
x65 = x54 * x60
x66 = x16 * (2.0 * x1 * x13 * x14 * x42 * x60 * x9 - x15 * x61)
x67 = x16 * x60 * (2.0 * x1 * x13 * x14 * x15 * x9 - x12)
x68 = x24 * x60
x69 = -x48 - A[1]
x70 = x25 * x69
x71 = x31 * x69
x72 = x1 * x69 * (2.0 * x1 * x13 * x14 * x15 * x9 - x12)
x73 = x35 * x69
x74 = x37 * x69
x75 = x39 * x69
x76 = x1 * (2.0 * x1 * x13 * x14 * x26 * x69 * x8 * x9 - x75)
x77 = x41 * x69
x78 = 0.2581988897471611 * x46
x79 = x58 * x69
x80 = x31 + x79
x81 = x49 * x69
x82 = x21 * x81
x83 = x25 + x82
x84 = x6 * x83
x85 = x36 * x81
x86 = x35 + x85
x87 = x1 * (x80 - x84)
x88 = x1 * x69 * (2.0 * x1 * x13 * x14 * x60 * x8 * x9 - x62)
x89 = -x59 - A[2]
x90 = x25 * x89
x91 = x31 * x89
x92 = x1 * x89 * (2.0 * x1 * x13 * x14 * x15 * x9 - x12)
x93 = 0.5 * x92
x94 = x35 * x89
x95 = x1 * x89 * (2.0 * x1 * x13 * x14 * x26 * x8 * x9 - x39)
x96 = 0.5 * x95
x97 = x1 * x89 * (2.0 * x1 * x13 * x14 * x49 * x8 * x9 - x51)
x98 = 0.5 * x97
x99 = x31 + x68 * x89
x100 = x60 * x89
x101 = x100 * x21 + x25
x102 = x101 * x6
x103 = x100 * x36 + x35
x104 = x103 * x18
x105 = x1 * (-x102 + x99)
x106 = 0.5 * x105
x107 = x69**2
x108 = x107 * x21
x109 = x108 + x17
x110 = x0 * x109
x111 = x107 * x36
x112 = x111 * x26
x113 = x112 + x40
x114 = x107 * x32 + x43 - x6 * (x108 * x26 + x44)
x115 = 0.3333333333333333 * x46
x116 = x53 + x69 * x86 + x73
x117 = x56 - x6 * (x57 + x69 * x83 + x70) + x69 * x80 + x71
x118 = x111 * x60 + x64
x119 = x107 * x68 - x6 * (x108 * x60 + x67) + x66
x120 = x73 * x89
x121 = x1 * x89 * (2.0 * x1 * x13 * x14 * x26 * x69 * x8 * x9 - x75)
x122 = 1.732050807568877 * x115
x123 = x85 * x89 + x94
x124 = x1 * (-x6 * (x82 * x89 + x90) + x79 * x89 + x91)
x125 = x1 * x69 * (-x102 + x99)
x126 = x89**2
x127 = x126 * x21
x128 = x127 + x17
x129 = x0 * x128
x130 = x126 * x36
x131 = x130 * x26 + x40
x132 = x131 * x5
x133 = x126 * x32 + x43 - x6 * (x127 * x26 + x44)
x134 = x133 * x16
x135 = x130 * x49 + x53
x136 = x126 * x58 + x56 - x6 * (x127 * x49 + x57)
x137 = x136 * x16
x138 = x103 * x89 + x64 + x94
x139 = -x6 * (x101 * x89 + x67 + x90) + x66 + x89 * x99 + x91
x140 = x139 * x16
x141 = x0 * (x109 * x69 + x72)
x142 = x113 * x69 + x76
x143 = x110 + x116 * x69 + x87
x144 = x5 * x78
x145 = x118 * x69 + x88
x146 = x0 * (x108 * x89 + x93)
x147 = x112 * x89 + x96
x148 = x120 + x123 * x69 + x98
x149 = x122 * x5
x150 = x103 * x107 + x106
x151 = x129 * x69
x152 = x129 + x135 * x69
x153 = x0 * (x128 * x89 + x92)
x154 = x131 * x89 + x95
x155 = x135 * x89 + x97
x156 = x105 + x129 + x138 * x89
x157 = x69 * x78
# 45 item(s)
result[0, 0] = numpy.sum(
x47
* (
x0 * x5 * (x1 * (2.0 * x1 * x13 * x14 * x15 * x9 - x12) + x23)
+ x45 * (x0 * x30 * x5 + x34 * x5 + x43 - x6 * (x25 * x5 + x29 * x5 + x44))
+ x5
* (x0 * x23 - x1 * (x29 * x6 - x34) + x5 * (x40 + x41 + x5 * (x35 + x37)))
)
)
result[0, 1] = numpy.sum(
x47
* (
x45 * (x18 * x58 + x56 - x6 * (x22 * x49 + x57))
+ x5
* (x1 * (2.0 * x1 * x13 * x14 * x49 * x5 * x8 * x9 - x52) + x5 * (x53 + x55))
)
)
result[0, 2] = numpy.sum(
x47
* (
x45 * (x18 * x68 - x6 * (x22 * x60 + x67) + x66)
+ x5
* (x1 * (2.0 * x1 * x13 * x14 * x5 * x60 * x8 * x9 - x63) + x5 * (x64 + x65))
)
)
result[1, 0] = numpy.sum(
0.5
* x78
* (
x0 * (2.0 * x22 * x69 + x72)
+ 2.0 * x1 * (x33 * x69 - x6 * (x28 * x69 + x70) + x71)
+ x5 * (2.0 * x5 * (x73 + x74) + x76 + 2.0 * x77)
)
)
result[1, 1] = numpy.sum(
0.5 * x5 * x78 * (2.0 * x1 * (x80 - x84) + 2.0 * x18 * x86 + x87)
)
result[1, 2] = numpy.sum(
0.5
* x78
* (
2.0 * x1 * x69 * (2.0 * x1 * x13 * x14 * x5 * x60 * x8 * x9 - x63)
+ x5 * (2.0 * x65 * x69 + x88)
)
)
result[2, 0] = numpy.sum(
x78
* (
x0 * (x22 * x89 + x93)
+ x1 * (x33 * x89 - x6 * (x28 * x89 + x90) + x91)
+ x5 * (x41 * x89 + x5 * (x37 * x89 + x94) + x96)
)
)
result[2, 1] = numpy.sum(
x78
* (
x1 * x89 * (2.0 * x1 * x13 * x14 * x49 * x5 * x8 * x9 - x52)
+ x5 * (x55 * x89 + x98)
)
)
result[2, 2] = numpy.sum(x5 * x78 * (-x1 * (x102 - x99) + x104 + x106))
result[3, 0] = numpy.sum(x115 * (x110 * x5 + x114 * x16 + x5 * (x110 + x113 * x5)))
result[3, 1] = numpy.sum(x115 * (x116 * x18 + x117 * x16))
result[3, 2] = numpy.sum(x115 * (x118 * x18 + x119 * x16))
result[4, 0] = numpy.sum(
0.5 * x122 * (x121 + 2.0 * x5 * (x120 + x74 * x89) + 2.0 * x77 * x89)
)
result[4, 1] = numpy.sum(0.5 * x122 * (2.0 * x123 * x18 + x124))
result[4, 2] = numpy.sum(0.5 * x122 * (2.0 * x104 * x69 + x125))
result[5, 0] = numpy.sum(x115 * (x129 * x5 + x134 + x5 * (x129 + x132)))
result[5, 1] = numpy.sum(x115 * (x135 * x18 + x137))
result[5, 2] = numpy.sum(x115 * (x138 * x18 + x140))
result[6, 0] = numpy.sum(x78 * (x141 + x142 * x5))
result[6, 1] = numpy.sum(x143 * x144)
result[6, 2] = numpy.sum(x144 * x145)
result[7, 0] = numpy.sum(x122 * (x146 + x147 * x5))
result[7, 1] = numpy.sum(x148 * x149)
result[7, 2] = numpy.sum(x149 * x150)
result[8, 0] = numpy.sum(x122 * (x132 * x69 + x151))
result[8, 1] = numpy.sum(x149 * x152)
result[8, 2] = numpy.sum(x138 * x149 * x69)
result[9, 0] = numpy.sum(x78 * (x153 + x154 * x5))
result[9, 1] = numpy.sum(x144 * x155)
result[9, 2] = numpy.sum(x144 * x156)
result[10, 0] = numpy.sum(x47 * (x114 * x45 + x142 * x69))
result[10, 1] = numpy.sum(x47 * (x117 * x45 + x141 + x143 * x69))
result[10, 2] = numpy.sum(x47 * (x119 * x45 + x145 * x69))
result[11, 0] = numpy.sum(x78 * (x121 + x147 * x69))
result[11, 1] = numpy.sum(x78 * (x124 + x146 + x148 * x69))
result[11, 2] = numpy.sum(x78 * (x125 + x150 * x69))
result[12, 0] = numpy.sum(x115 * (x107 * x131 + x134))
result[12, 1] = numpy.sum(x115 * (x137 + x151 + x152 * x69))
result[12, 2] = numpy.sum(x115 * (x107 * x138 + x140))
result[13, 0] = numpy.sum(x154 * x157)
result[13, 1] = numpy.sum(x78 * (x153 + x155 * x69))
result[13, 2] = numpy.sum(x156 * x157)
result[14, 0] = numpy.sum(x47 * (x133 * x45 + x154 * x89))
result[14, 1] = numpy.sum(x47 * (x136 * x45 + x155 * x89))
result[14, 2] = numpy.sum(x47 * (x139 * x45 + x153 + x156 * x89))
return result
[docs]
def int2c2e3d_42(ax, da, A, bx, db, B):
"""Cartesian (g|d) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((15, 6), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - A[0]
x4 = ax ** (-1.0)
x5 = bx * x1
x6 = ax * x5 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x7 = boys(4, x6)
x8 = x0 ** (-1.5)
x9 = bx ** (-1.0)
x10 = 17.49341832762486
x11 = x10 * x9
x12 = 2.0 * x11
x13 = x12 * x8
x14 = x0 ** (-0.5)
x15 = boys(3, x6)
x16 = 0.5 * x9
x17 = x16 * (2.0 * x10 * x14 * x15 * x4 * x9 - x13 * x7)
x18 = boys(5, x6)
x19 = -x2 - B[0]
x20 = x19**2
x21 = x12 * x14
x22 = x21 * x4
x23 = x20 * x22
x24 = x17 + x18 * x23
x25 = x24 * x3
x26 = x4 * x7
x27 = 0.5 / (ax + bx)
x28 = x11 * x14
x29 = 4.0 * x27 * x28
x30 = x19 * x29
x31 = x26 * x30
x32 = x25 + x31
x33 = boys(2, x6)
x34 = -2.0 * x10 * x14 * x33 * x4 * x9
x35 = -x16 * (x13 * x15 + x34)
x36 = x22 * x7
x37 = x20 * x36 + x35
x38 = x3 * x37
x39 = x15 * x4
x40 = x30 * x39
x41 = x38 + x40
x42 = x16 * (2.0 * x10 * x14 * x4 * x7 * x9 - x13 * x18)
x43 = boys(6, x6)
x44 = x23 * x43 + x42
x45 = x3 * x44
x46 = x18 * x4
x47 = x30 * x46
x48 = x24 * x5
x49 = 0.5 * x4
x50 = x49 * (x37 - x48)
x51 = 2.0 * x27
x52 = x28 * x51
x53 = x26 * x52
x54 = x19 * x3
x55 = x18 * x22
x56 = x54 * x55
x57 = x53 + x56
x58 = 2.0 * x10 * x8
x59 = x26 * x58
x60 = x19 * x59
x61 = x49 * (2.0 * x10 * x14 * x15 * x19 * x4 * x9 - x60)
x62 = x3 * x53
x63 = x3 * x57 + x61 + x62
x64 = x39 * x52
x65 = x36 * x54 + x64
x66 = x4 * x52
x67 = x33 * x66
x68 = x21 * x39
x69 = x19 * x3 * x68 + x67
x70 = x39 * x58
x71 = -x49 * (x34 + x70)
x72 = x3**2
x73 = x36 * x72
x74 = boys(1, x6)
x75 = x16 * (2.0 * x10 * x14 * x4 * x9 * boys(0, x6) - x13 * x74)
x76 = x16 * (2.0 * x10 * x14 * x4 * x74 * x9 - x13 * x33)
x77 = x20 * x68 + x76
x78 = x22 * x33
x79 = x49 * (x20 * x78 - x5 * x77 + x75)
x80 = x49 * (-x37 * x5 + x77)
x81 = 1.5 * x4
x82 = da * db
x83 = 0.009523809523809524 * x82
x84 = 5.916079783099616 * x83
x85 = -x1 * (ax * A[1] + bx * B[1])
x86 = -x85 - B[1]
x87 = x59 * x86
x88 = x49 * (2.0 * x10 * x14 * x15 * x4 * x86 * x9 - x87)
x89 = x55 * x72
x90 = x86 * x89
x91 = x88 + x90
x92 = x53 * x86
x93 = x19 * x86
x94 = x3 * x93
x95 = x55 * x94
x96 = x92 + x95
x97 = x64 * x86
x98 = x36 * x93
x99 = x3 * x98
x100 = x97 + x99
x101 = x18 * x66
x102 = x101 * x86
x103 = x22 * x43
x104 = x103 * x94
x105 = x46 * x58
x106 = x105 * x93
x107 = x49 * (2.0 * x10 * x14 * x19 * x4 * x7 * x86 * x9 - x106)
x108 = x102 * x3
x109 = x49 * (2.0 * x10 * x14 * x19 * x33 * x4 * x86 * x9 - x70 * x93)
x110 = x49 * x86 * (2.0 * x10 * x14 * x15 * x19 * x4 * x9 - x60)
x111 = 10.2469507659596 * x83
x112 = -x1 * (ax * A[2] + bx * B[2])
x113 = -x112 - B[2]
x114 = x113 * x59
x115 = x49 * (2.0 * x10 * x113 * x14 * x15 * x4 * x9 - x114)
x116 = x113 * x89
x117 = x115 + x116
x118 = x113 * x53
x119 = x113 * x19
x120 = x119 * x3
x121 = x120 * x55
x122 = x118 + x121
x123 = x113 * x64
x124 = x119 * x36
x125 = x124 * x3
x126 = x123 + x125
x127 = x101 * x113
x128 = x103 * x120
x129 = x105 * x119
x130 = x49 * (2.0 * x10 * x113 * x14 * x19 * x4 * x7 * x9 - x129)
x131 = x127 * x3
x132 = x49 * (2.0 * x10 * x113 * x14 * x19 * x33 * x4 * x9 - x119 * x70)
x133 = x113 * x49 * (2.0 * x10 * x14 * x15 * x19 * x4 * x9 - x60)
x134 = x86**2
x135 = x134 * x36 + x35
x136 = x134 * x22
x137 = x136 * x18 + x17
x138 = x137 * x5
x139 = x138 * x3
x140 = x136 * x43 + x42
x141 = x140 * x72
x142 = x49 * (x135 - x138)
x143 = x134 * x68 + x76
x144 = x49 * (x134 * x78 - x143 * x5 + x75)
x145 = x49 * (-x135 * x5 + x143)
x146 = x113 * x86
x147 = x105 * x146
x148 = x49 * (2.0 * x10 * x113 * x14 * x4 * x7 * x86 * x9 - x147)
x149 = x103 * x146
x150 = x49 * (2.0 * x10 * x113 * x14 * x33 * x4 * x86 * x9 - x146 * x70)
x151 = x113 * x49 * (2.0 * x10 * x14 * x15 * x4 * x86 * x9 - x87)
x152 = x113**2
x153 = x152 * x36 + x35
x154 = x152 * x22
x155 = x154 * x18 + x17
x156 = x155 * x5
x157 = x156 * x3
x158 = x154 * x43 + x42
x159 = x158 * x72
x160 = x49 * (x153 - x156)
x161 = x152 * x68 + x76
x162 = x49 * (x152 * x78 - x161 * x5 + x75)
x163 = x49 * (-x153 * x5 + x161)
x164 = -x85 - A[1]
x165 = x164 * x45
x166 = x164 * x47
x167 = x164 * x48
x168 = x4 * (x164 * x37 - x167)
x169 = x164 * x53
x170 = x164 * x56
x171 = x169 + x170
x172 = x164 * x4 * (2.0 * x10 * x14 * x15 * x19 * x4 * x9 - x60)
x173 = 0.06666666666666667 * x82
x174 = 2.23606797749979 * x173
x175 = x164 * x68 * x86 + x67
x176 = x175 * x27
x177 = x19 * x64
x178 = x164 * x98
x179 = x177 + x178
x180 = x164 * x86
x181 = x180 * x36 + x64
x182 = x181 * x27
x183 = x19 * x53
x184 = x164 * x93
x185 = x184 * x55
x186 = x183 + x185
x187 = x180 * x55
x188 = x187 + x53
x189 = x4 * (x175 - x181 * x5)
x190 = x188 * x27
x191 = x101 * x19
x192 = x103 * x184
x193 = x191 + x192
x194 = x4 * (x179 - x186 * x5)
x195 = 3.872983346207417 * x173
x196 = x118 * x164
x197 = x123 * x164
x198 = x164 * x4 * (2.0 * x10 * x113 * x14 * x15 * x4 * x9 - x114)
x199 = x127 * x164
x200 = x164 * x4 * (2.0 * x10 * x113 * x14 * x19 * x4 * x7 * x9 - x129)
x201 = x135 * x164
x202 = x29 * x86
x203 = x202 * x39
x204 = x201 + x203
x205 = x137 * x164
x206 = x202 * x26
x207 = x205 + x206
x208 = x207 * x5
x209 = x140 * x164
x210 = x202 * x46
x211 = x209 + x210
x212 = x4 * (x204 - x208)
x213 = x146 * x36
x214 = x123 + x164 * x213
x215 = x146 * x55
x216 = x118 + x164 * x215
x217 = x216 * x5
x218 = x127 + x149 * x164
x219 = x4 * (x214 - x217)
x220 = x164 * x4 * (x153 - x156)
x221 = -x112 - A[2]
x222 = x221 * x4 * (x37 - x48)
x223 = 0.5 * x222
x224 = x221 * x53
x225 = x221 * x56 + x224
x226 = x221 * x4 * (2.0 * x10 * x14 * x15 * x19 * x4 * x9 - x60)
x227 = 0.5 * x226
x228 = x221 * x92
x229 = x221 * x97
x230 = x221 * x4 * (2.0 * x10 * x14 * x15 * x4 * x86 * x9 - x87)
x231 = 0.5 * x230
x232 = x102 * x221
x233 = x221 * x4 * (2.0 * x10 * x14 * x19 * x4 * x7 * x86 * x9 - x106)
x234 = 0.5 * x233
x235 = x113 * x221 * x68 + x67
x236 = x235 * x27
x237 = x124 * x221 + x177
x238 = x113 * x221
x239 = x238 * x36 + x64
x240 = x239 * x27
x241 = x119 * x221
x242 = x183 + x241 * x55
x243 = x238 * x55 + x53
x244 = x4 * (x235 - x239 * x5)
x245 = 0.5 * x244
x246 = x243 * x27
x247 = x103 * x241 + x191
x248 = x247 * x3
x249 = x242 * x5
x250 = x4 * (x237 - x249)
x251 = 0.5 * x250
x252 = x246 * x3
x253 = x221 * x4 * (x135 - x138)
x254 = 0.5 * x253
x255 = x213 * x221 + x97
x256 = x215 * x221 + x92
x257 = x256 * x5
x258 = x102 + x149 * x221
x259 = x4 * (x255 - x257)
x260 = 0.5 * x259
x261 = x113 * x29
x262 = x153 * x221 + x261 * x39
x263 = x155 * x221 + x26 * x261
x264 = x263 * x5
x265 = x158 * x221 + x261 * x46
x266 = x265 * x72
x267 = x4 * (x262 - x264)
x268 = 0.5 * x267
x269 = x164**2
x270 = x269 * x44
x271 = x270 + x50
x272 = x269 * x55
x273 = x19 * x272
x274 = x273 + x61
x275 = x27 * x274
x276 = x269 * x37 - x5 * (x24 * x269 + x80) + x79
x277 = x269 * x36
x278 = x27 * (x277 + x71)
x279 = 1.732050807568877
x280 = 0.1111111111111111 * x279 * x82
x281 = x164 * x188 + x169 + x88
x282 = x27 * x281
x283 = x164 * x191
x284 = x107 + x164 * x193 + x283
x285 = x109 + x164 * x177 + x164 * x179 - x5 * (x110 + x164 * x186 + x169 * x19)
x286 = 0.3333333333333333 * x82
x287 = x113 * x272 + x115
x288 = x27 * x287
x289 = x103 * x119 * x269 + x130
x290 = x119 * x277 + x132 - x5 * (x119 * x272 + x133)
x291 = x142 + x164 * x211 + 2.0 * x190
x292 = x144 + x164 * x204 + 2.0 * x176 - x5 * (x145 + x164 * x207 + 2.0 * x182)
x293 = x148 + x164 * x218 + x199
x294 = x150 + x164 * x214 + x197 - x5 * (x151 + x164 * x216 + x196)
x295 = x158 * x269 + x160
x296 = x153 * x269 + x162 - x5 * (x155 * x269 + x163)
x297 = x221 * x4 * (x164 * x37 - x167)
x298 = x169 * x221
x299 = x187 * x221 + x224
x300 = x27 * x299
x301 = x191 * x221
x302 = x192 * x221 + x301
x303 = x183 * x221
x304 = x177 * x221
x305 = x4 * (x178 * x221 + x304 - x5 * (x185 * x221 + x303))
x306 = x279 * x286
x307 = x164 * x246
x308 = x164 * x4 * (x237 - x249)
x309 = x221 * (x209 + x210)
x310 = x221 * x4 * (x201 + x203 - x5 * (x205 + x206))
x311 = x164 * x258 + x246
x312 = x4 * (x164 * x255 + x236 - x5 * (x164 * x256 + x240))
x313 = x164 * x4 * (x262 - x264)
x314 = x221**2
x315 = x314 * x44 + x50
x316 = x3 * x315
x317 = x314 * x55
x318 = x19 * x317 + x61
x319 = x27 * x318
x320 = 2.0 * x319
x321 = x314 * x37 - x5 * (x24 * x314 + x80) + x79
x322 = x321 * x49
x323 = x314 * x36
x324 = x27 * (x323 + x71)
x325 = x317 * x86 + x88
x326 = x27 * x325
x327 = x103 * x314 * x93 + x107
x328 = x109 + x323 * x93 - x5 * (x110 + x317 * x93)
x329 = x328 * x49
x330 = x115 + x221 * x243 + x224
x331 = x27 * x330
x332 = x130 + x221 * x247 + x301
x333 = x3 * x332
x334 = x132 + x221 * x237 + x304 - x5 * (x133 + x221 * x242 + x303)
x335 = x334 * x49
x336 = x140 * x314 + x142
x337 = x135 * x314 + x144 - x5 * (x137 * x314 + x145)
x338 = x337 * x49
x339 = x148 + x221 * x258 + x232
x340 = x150 + x221 * x255 + x229 - x5 * (x151 + x221 * x256 + x228)
x341 = x340 * x49
x342 = x160 + x221 * x265 + 2.0 * x246
x343 = x162 + x221 * x262 + 2.0 * x236 - x5 * (x163 + x221 * x263 + 2.0 * x240)
x344 = x343 * x49
x345 = x164 * x271 + x168
x346 = x27 * (x164 * x274 + x172)
x347 = x27 * (x164 * x281 + x189 + x278)
x348 = x164 * x284 + x194 + x275
x349 = x27 * (x164 * x287 + x198)
x350 = x164 * x289 + x200
x351 = x164 * x291 + x212 + 2.0 * x282
x352 = x174 * x3
x353 = x164 * x293 + x219 + x288
x354 = x195 * x3
x355 = x164 * x295 + x220
x356 = x221 * x270 + x223
x357 = x27 * (x221 * x273 + x227)
x358 = x27 * (x164 * x299 + x231 + x298)
x359 = x164 * x302 + x221 * x283 + x234
x360 = x27 * (x243 * x269 + x245)
x361 = x247 * x269 + x251
x362 = x164 * x309 + x254 + 2.0 * x300
x363 = x286 * x3
x364 = x164 * x311 + x260 + x307
x365 = x3 * x306
x366 = x265 * x269 + x268
x367 = x27 * (x164 * x325 + x324)
x368 = x164 * x327 + x319
x369 = x164 * x331
x370 = x164 * x336 + 2.0 * x326
x371 = x164 * x339 + x331
x372 = x221 * x315 + x222
x373 = x27 * (x221 * x318 + x226)
x374 = x27 * (x221 * x325 + x230)
x375 = x221 * x327 + x233
x376 = x27 * (x221 * x330 + x244 + x324)
x377 = x221 * x332 + x250 + x319
x378 = x221 * x336 + x253
x379 = x221 * x339 + x259 + x326
x380 = x221 * x342 + x267 + 2.0 * x331
x381 = x164 * x174
# 90 item(s)
result[0, 0] = numpy.sum(
x84
* (
x3
* (
x3 * (x3 * (x45 + x47) + x50 + x51 * x57)
- x4 * (x32 * x5 - x41)
+ x51 * x63
)
+ x51 * (x27 * (x71 + x73) + x3 * x63 - x4 * (x5 * x65 - x69))
+ x81 * (x3 * x41 - x5 * (x3 * x32 + x51 * x65 + x80) + x51 * x69 + x79)
)
)
result[0, 1] = numpy.sum(
x111
* (
x27 * x3 * (x4 * (2.0 * x10 * x14 * x15 * x4 * x86 * x9 - x87) + x91)
+ x3
* (
x27 * x91
+ x3 * (x107 + x108 + x3 * (x102 + x104))
+ x4 * (x100 - x5 * x96)
)
+ x81 * (x100 * x3 + x109 + x3 * x97 - x5 * (x110 + x3 * x96 + x62 * x86))
)
)
result[0, 2] = numpy.sum(
x111
* (
x27 * x3 * (x117 + x4 * (2.0 * x10 * x113 * x14 * x15 * x4 * x9 - x114))
+ x3
* (
x117 * x27
+ x3 * (x130 + x131 + x3 * (x127 + x128))
- x4 * (x122 * x5 - x126)
)
+ x81 * (x123 * x3 + x126 * x3 + x132 - x5 * (x113 * x62 + x122 * x3 + x133))
)
)
result[0, 3] = numpy.sum(
x84
* (
x3 * (x3 * (x141 + x142) + x4 * (x135 * x3 - x139))
+ x81 * (x135 * x72 + x144 - x5 * (x137 * x72 + x145))
)
)
result[0, 4] = numpy.sum(
x111
* (
x3**2
* (
x148
+ x149 * x72
+ x4 * (2.0 * x10 * x113 * x14 * x4 * x7 * x86 * x9 - x147)
)
+ x81 * (x146 * x73 + x150 - x5 * (x146 * x89 + x151))
)
)
result[0, 5] = numpy.sum(
x84
* (
x3 * (x3 * (x159 + x160) + x4 * (x153 * x3 - x157))
+ x81 * (x153 * x72 + x162 - x5 * (x155 * x72 + x163))
)
)
result[1, 0] = numpy.sum(
0.5
* x174
* (
2.0 * x164 * x4 * (x38 + x40 - x5 * (x25 + x31))
+ x3 * (x168 + 2.0 * x171 * x51 + 2.0 * x3 * (x165 + x166))
+ x51 * (2.0 * x164 * x62 + 2.0 * x171 * x3 + x172)
)
)
result[1, 1] = numpy.sum(
0.5
* x195
* (
x27 * (2.0 * x188 * x72 + x189)
+ x3 * (2.0 * x190 * x3 + x194 + 2.0 * x3 * (x190 + x193 * x3))
+ 2.0 * x4 * (x176 + x179 * x3 - x5 * (x182 + x186 * x3))
)
)
result[1, 2] = numpy.sum(
0.5
* x195
* (
x27 * (2.0 * x116 * x164 + x198)
+ x3 * (2.0 * x131 * x164 + x200 + 2.0 * x3 * (x128 * x164 + x199))
+ 2.0 * x4 * (x125 * x164 + x197 - x5 * (x121 * x164 + x196))
)
)
result[1, 3] = numpy.sum(
0.5 * x174 * x3 * (2.0 * x211 * x72 + x212 + 2.0 * x4 * (x204 - x208))
)
result[1, 4] = numpy.sum(
0.5 * x195 * x3 * (2.0 * x218 * x72 + x219 + 2.0 * x4 * (x214 - x217))
)
result[1, 5] = numpy.sum(
0.5
* x174
* (2.0 * x164 * x4 * (x153 * x3 - x157) + x3 * (2.0 * x159 * x164 + x220))
)
result[2, 0] = numpy.sum(
x174
* (
x221 * x4 * (x38 + x40 - x5 * (x25 + x31))
+ x3 * (x221 * x3 * (x45 + x47) + x223 + x225 * x51)
+ x51 * (x221 * x62 + x225 * x3 + x227)
)
)
result[2, 1] = numpy.sum(
x195
* (
x27 * (x221 * x90 + x231)
+ x3 * (x108 * x221 + x234 + x3 * (x104 * x221 + x232))
+ x4 * (x221 * x99 + x229 - x5 * (x221 * x95 + x228))
)
)
result[2, 2] = numpy.sum(
x195
* (
x27 * (x243 * x72 + x245)
+ x3 * (x251 + x252 + x3 * (x246 + x248))
+ x4 * (x236 + x237 * x3 - x5 * (x240 + x242 * x3))
)
)
result[2, 3] = numpy.sum(
x174 * (x221 * x4 * (x135 * x3 - x139) + x3 * (x141 * x221 + x254))
)
result[2, 4] = numpy.sum(x195 * x3 * (x258 * x72 + x260 + x4 * (x255 - x257)))
result[2, 5] = numpy.sum(x174 * x3 * (x266 + x268 + x4 * (x262 - x264)))
result[3, 0] = numpy.sum(
x280 * (x276 * x49 + x3 * (x271 * x3 + 2.0 * x275) + x51 * (x274 * x3 + x278))
)
result[3, 1] = numpy.sum(x286 * (x282 * x3 + x285 * x49 + x3 * (x282 + x284 * x3)))
result[3, 2] = numpy.sum(x286 * (x288 * x3 + x290 * x49 + x3 * (x288 + x289 * x3)))
result[3, 3] = numpy.sum(x280 * (x291 * x72 + x292 * x49))
result[3, 4] = numpy.sum(x286 * (x293 * x72 + x294 * x49))
result[3, 5] = numpy.sum(x280 * (x295 * x72 + x296 * x49))
result[4, 0] = numpy.sum(
0.5
* x286
* (2.0 * x221 * x3 * (x165 + x166) + x297 + 2.0 * x51 * (x170 * x221 + x298))
)
result[4, 1] = numpy.sum(0.5 * x306 * (2.0 * x3**2 * x302 + 4.0 * x3 * x300 + x305))
result[4, 2] = numpy.sum(
0.5 * x306 * (2.0 * x164 * x252 + 2.0 * x3 * (x164 * x248 + x307) + x308)
)
result[4, 3] = numpy.sum(0.5 * x286 * (2.0 * x309 * x72 + x310))
result[4, 4] = numpy.sum(0.5 * x306 * (2.0 * x311 * x72 + x312))
result[4, 5] = numpy.sum(0.5 * x286 * (2.0 * x164 * x266 + x313))
result[5, 0] = numpy.sum(
x280 * (x3 * (x316 + x320) + x322 + x51 * (x3 * x318 + x324))
)
result[5, 1] = numpy.sum(x286 * (x3 * x326 + x3 * (x3 * x327 + x326) + x329))
result[5, 2] = numpy.sum(x286 * (x3 * x331 + x3 * (x331 + x333) + x335))
result[5, 3] = numpy.sum(x280 * (x336 * x72 + x338))
result[5, 4] = numpy.sum(x286 * (x339 * x72 + x341))
result[5, 5] = numpy.sum(x280 * (x342 * x72 + x344))
result[6, 0] = numpy.sum(x174 * (x3 * x345 + 2.0 * x346))
result[6, 1] = numpy.sum(x195 * (x3 * x348 + x347))
result[6, 2] = numpy.sum(x195 * (x3 * x350 + x349))
result[6, 3] = numpy.sum(x351 * x352)
result[6, 4] = numpy.sum(x353 * x354)
result[6, 5] = numpy.sum(x352 * x355)
result[7, 0] = numpy.sum(x286 * (x3 * x356 + 2.0 * x357))
result[7, 1] = numpy.sum(x306 * (x3 * x359 + x358))
result[7, 2] = numpy.sum(x306 * (x3 * x361 + x360))
result[7, 3] = numpy.sum(x362 * x363)
result[7, 4] = numpy.sum(x364 * x365)
result[7, 5] = numpy.sum(x363 * x366)
result[8, 0] = numpy.sum(x164 * x286 * (x316 + x320))
result[8, 1] = numpy.sum(x306 * (x3 * x368 + x367))
result[8, 2] = numpy.sum(x306 * (x164 * x333 + x369))
result[8, 3] = numpy.sum(x363 * x370)
result[8, 4] = numpy.sum(x365 * x371)
result[8, 5] = numpy.sum(x164 * x342 * x363)
result[9, 0] = numpy.sum(x174 * (x3 * x372 + 2.0 * x373))
result[9, 1] = numpy.sum(x195 * (x3 * x375 + x374))
result[9, 2] = numpy.sum(x195 * (x3 * x377 + x376))
result[9, 3] = numpy.sum(x352 * x378)
result[9, 4] = numpy.sum(x354 * x379)
result[9, 5] = numpy.sum(x352 * x380)
result[10, 0] = numpy.sum(x84 * (x164 * x345 + x276 * x81))
result[10, 1] = numpy.sum(x111 * (x164 * x348 + x285 * x81 + x346))
result[10, 2] = numpy.sum(x111 * (x164 * x350 + x290 * x81))
result[10, 3] = numpy.sum(x84 * (x164 * x351 + x292 * x81 + 2.0 * x347))
result[10, 4] = numpy.sum(x111 * (x164 * x353 + x294 * x81 + x349))
result[10, 5] = numpy.sum(x84 * (x164 * x355 + x296 * x81))
result[11, 0] = numpy.sum(x174 * (x164 * x356 + x297))
result[11, 1] = numpy.sum(x195 * (x164 * x359 + x305 + x357))
result[11, 2] = numpy.sum(x195 * (x164 * x361 + x308))
result[11, 3] = numpy.sum(x174 * (x164 * x362 + x310 + 2.0 * x358))
result[11, 4] = numpy.sum(x195 * (x164 * x364 + x312 + x360))
result[11, 5] = numpy.sum(x174 * (x164 * x366 + x313))
result[12, 0] = numpy.sum(x280 * (x269 * x315 + x322))
result[12, 1] = numpy.sum(x286 * (x164 * x319 + x164 * x368 + x329))
result[12, 2] = numpy.sum(x286 * (x269 * x332 + x335))
result[12, 3] = numpy.sum(x280 * (x164 * x370 + x338 + 2.0 * x367))
result[12, 4] = numpy.sum(x286 * (x164 * x371 + x341 + x369))
result[12, 5] = numpy.sum(x280 * (x269 * x342 + x344))
result[13, 0] = numpy.sum(x372 * x381)
result[13, 1] = numpy.sum(x195 * (x164 * x375 + x373))
result[13, 2] = numpy.sum(x164 * x195 * x377)
result[13, 3] = numpy.sum(x174 * (x164 * x378 + 2.0 * x374))
result[13, 4] = numpy.sum(x195 * (x164 * x379 + x376))
result[13, 5] = numpy.sum(x380 * x381)
result[14, 0] = numpy.sum(x84 * (x221 * x372 + x321 * x81))
result[14, 1] = numpy.sum(x111 * (x221 * x375 + x328 * x81))
result[14, 2] = numpy.sum(x111 * (x221 * x377 + x334 * x81 + x373))
result[14, 3] = numpy.sum(x84 * (x221 * x378 + x337 * x81))
result[14, 4] = numpy.sum(x111 * (x221 * x379 + x340 * x81 + x374))
result[14, 5] = numpy.sum(x84 * (x221 * x380 + x343 * x81 + 2.0 * x376))
return result
[docs]
def int2c2e3d_43(ax, da, A, bx, db, B):
"""Cartesian (g|f) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((15, 10), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - A[0]
x4 = ax ** (-1.0)
x5 = bx ** (-1.0)
x6 = -x2 - B[0]
x7 = bx * x1
x8 = ax * x7 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x9 = boys(5, x8)
x10 = x0 ** (-1.5)
x11 = 17.49341832762486
x12 = x11 * x5
x13 = 2.0 * x12
x14 = x10 * x13
x15 = x14 * x9
x16 = x0 ** (-0.5)
x17 = boys(4, x8)
x18 = 0.5 * x5
x19 = x18 * (2.0 * x11 * x16 * x17 * x4 * x5 - x15)
x20 = boys(6, x8)
x21 = x6**2
x22 = x16 * x4
x23 = x13 * x22
x24 = x21 * x23
x25 = x20 * x24
x26 = x19 + x25
x27 = x6 * (x26 + x5 * (2.0 * x11 * x16 * x17 * x4 * x5 - x15))
x28 = x27 * x3
x29 = 0.5 / (ax + bx)
x30 = x14 * x17
x31 = boys(3, x8)
x32 = x18 * (2.0 * x11 * x16 * x31 * x4 * x5 - x30)
x33 = x23 * x9
x34 = x21 * x33
x35 = x32 + x34
x36 = x29 * x35
x37 = 3.0 * x36
x38 = x28 + x37
x39 = -2.0 * x11 * x16 * x31 * x4 * x5 * x6
x40 = x35 * x6 - x5 * (x30 * x6 + x39)
x41 = x3 * x40
x42 = x14 * x31
x43 = boys(2, x8)
x44 = x18 * (2.0 * x11 * x16 * x4 * x43 * x5 - x42)
x45 = x17 * x23
x46 = x21 * x45
x47 = x44 + x46
x48 = x29 * x47
x49 = 3.0 * x48
x50 = x41 + x49
x51 = x14 * x20
x52 = x18 * (2.0 * x11 * x16 * x4 * x5 * x9 - x51)
x53 = boys(7, x8)
x54 = x24 * x53
x55 = x6 * (x5 * (2.0 * x11 * x16 * x4 * x5 * x9 - x51) + x52 + x54)
x56 = x3 * x55
x57 = x26 * x29
x58 = 3.0 * x57
x59 = x27 * x7
x60 = 0.5 * x4
x61 = x60 * (x40 - x59)
x62 = x26 * x3
x63 = x6 * x9
x64 = x12 * x22
x65 = 4.0 * x29 * x64
x66 = x63 * x65
x67 = x62 + x66
x68 = 3.0 * x29
x69 = x35 * x7
x70 = x60 * (x47 - x69)
x71 = 2.0 * x29
x72 = x64 * x71
x73 = x17 * x72
x74 = x3 * x6
x75 = x33 * x74
x76 = x73 + x75
x77 = x3 * x67 + x70 + x71 * x76
x78 = x17 * x6
x79 = x65 * x78
x80 = x3 * x35 + x79
x81 = x31 * x6
x82 = x3 * x47 + x65 * x81
x83 = 2.0 * x10 * x11 * x4
x84 = x78 * x83
x85 = -x60 * (x39 + x84)
x86 = x3 * x73
x87 = x14 * x43
x88 = boys(1, x8)
x89 = x18 * (2.0 * x11 * x16 * x4 * x5 * x88 - x87)
x90 = x23 * x31
x91 = x21 * x90
x92 = x6 * (x47 + x5 * (2.0 * x11 * x16 * x4 * x43 * x5 - x42))
x93 = x60 * (
x5 * x6 * (2.0 * x11 * x16 * x4 * x5 * x88 - x87) + x6 * (x89 + x91) - x7 * x92
)
x94 = x60 * (-x40 * x7 + x92)
x95 = 1.5 * x4
x96 = da * db
x97 = 0.009523809523809524 * x96
x98 = 2.645751311064591 * x97
x99 = -x1 * (ax * A[1] + bx * B[1])
x100 = -x99 - B[1]
x101 = x100 * x5 * (2.0 * x11 * x16 * x17 * x4 * x5 - x15)
x102 = x100 * x25 + 0.5 * x101
x103 = x102 * x3
x104 = x100 * x66
x105 = x103 + x104
x106 = -2.0 * x100 * x11 * x16 * x31 * x4 * x5
x107 = -x5 * (x100 * x30 + x106)
x108 = x100 * x34 + 0.5 * x107
x109 = x108 * x3
x110 = x100 * x79
x111 = x109 + x110
x112 = x100 * x5 * (2.0 * x11 * x16 * x4 * x5 * x9 - x51)
x113 = x100 * x54 + 0.5 * x112
x114 = x113 * x3
x115 = x100 * x20
x116 = x115 * x6
x117 = x116 * x65
x118 = x102 * x7
x119 = x60 * (x108 - x118)
x120 = x100 * x9
x121 = x120 * x72
x122 = x23 * x74
x123 = x115 * x122
x124 = x121 + x123
x125 = x63 * x83
x126 = x100 * x125
x127 = x60 * (2.0 * x100 * x11 * x16 * x17 * x4 * x5 * x6 - x126)
x128 = x121 * x3
x129 = x124 * x3 + x127 + x128
x130 = x100 * x73
x131 = x100 * x33
x132 = x131 * x74
x133 = x130 + x132
x134 = x31 * x72
x135 = x100 * x134
x136 = x100 * x45
x137 = x135 + x136 * x74
x138 = x17 * x83
x139 = -x60 * (x100 * x138 + x106)
x140 = x3**2
x141 = x100 * x5 * (2.0 * x11 * x16 * x4 * x5 * x88 - x87)
x142 = x100 * x5 * (2.0 * x11 * x16 * x4 * x43 * x5 - x42)
x143 = x100 * x46 + 0.5 * x142
x144 = 0.5 * x60 * (2.0 * x100 * x91 + x141 - 2.0 * x143 * x7)
x145 = x60 * (-x108 * x7 + x143)
x146 = 5.916079783099616 * x97
x147 = -x1 * (ax * A[2] + bx * B[2])
x148 = -x147 - B[2]
x149 = x148 * x5 * (2.0 * x11 * x16 * x17 * x4 * x5 - x15)
x150 = 0.5 * x149
x151 = x148 * x25 + x150
x152 = x151 * x3
x153 = x148 * x66
x154 = x152 + x153
x155 = -2.0 * x11 * x148 * x16 * x31 * x4 * x5
x156 = -x5 * (x148 * x30 + x155)
x157 = 0.5 * x156
x158 = x148 * x34 + x157
x159 = x158 * x3
x160 = x148 * x79
x161 = x159 + x160
x162 = x148 * x5 * (2.0 * x11 * x16 * x4 * x5 * x9 - x51)
x163 = 0.5 * x162
x164 = x148 * x54 + x163
x165 = x164 * x3
x166 = x148 * x65
x167 = x20 * x6
x168 = x166 * x167
x169 = x151 * x7
x170 = x60 * (x158 - x169)
x171 = x148 * x9
x172 = x171 * x72
x173 = x122 * x148 * x20
x174 = x172 + x173
x175 = x125 * x148
x176 = x60 * (2.0 * x11 * x148 * x16 * x17 * x4 * x5 * x6 - x175)
x177 = x172 * x3
x178 = x174 * x3 + x176 + x177
x179 = x148 * x73
x180 = x148 * x33
x181 = x179 + x180 * x74
x182 = x134 * x148
x183 = x148 * x45
x184 = x182 + x183 * x74
x185 = -x60 * (x138 * x148 + x155)
x186 = x148 * x5 * (2.0 * x11 * x16 * x4 * x5 * x88 - x87)
x187 = 0.5 * x186
x188 = x148 * x5 * (2.0 * x11 * x16 * x4 * x43 * x5 - x42)
x189 = 0.5 * x188
x190 = x148 * x46 + x189
x191 = x60 * (x148 * x91 + x187 - x190 * x7)
x192 = x60 * (-x158 * x7 + x190)
x193 = x100**2
x194 = x193 * x45 + x44
x195 = x193 * x33 + x32
x196 = x195 * x7
x197 = x193 * x23
x198 = x197 * x20
x199 = x19 + x198
x200 = x140 * x199
x201 = x60 * (x194 - x196)
x202 = x200 + x201
x203 = x195 * x29
x204 = x199 * x74
x205 = x203 + x204
x206 = x194 * x29
x207 = x195 * x6
x208 = x207 * x3
x209 = x206 + x208
x210 = x199 * x29
x211 = x197 * x53
x212 = x211 + x52
x213 = x212 * x74
x214 = x6 * x7
x215 = x199 * x214
x216 = x60 * (x195 * x6 - x215)
x217 = x210 * x3
x218 = x193 * x90 + x89
x219 = x6 * x60 * (-x194 * x7 + x218)
x220 = x60 * (x194 * x6 - x207 * x7)
x221 = x148 * x83
x222 = x120 * x221
x223 = x60 * (2.0 * x100 * x11 * x148 * x16 * x17 * x4 * x5 - x222)
x224 = x115 * x148
x225 = x224 * x23
x226 = x140 * x225 + x223
x227 = x148 * (x121 + x123)
x228 = x148 * (x130 + x132)
x229 = x224 * x72
x230 = x100 * x148
x231 = x230 * x53
x232 = x60 * (2.0 * x100 * x11 * x148 * x16 * x4 * x5 * x6 * x9 - x116 * x221)
x233 = x60 * (2.0 * x100 * x11 * x148 * x16 * x31 * x4 * x5 * x6 - x230 * x84)
x234 = x148 * x60 * (2.0 * x100 * x11 * x16 * x17 * x4 * x5 * x6 - x126)
x235 = 10.2469507659596 * x97
x236 = x148**2
x237 = x236 * x45 + x44
x238 = x236 * x33 + x32
x239 = x238 * x7
x240 = x23 * x236
x241 = x19 + x20 * x240
x242 = x140 * x241
x243 = x60 * (x237 - x239)
x244 = x242 + x243
x245 = x238 * x29
x246 = x241 * x74
x247 = x245 + x246
x248 = x237 * x29
x249 = x238 * x6
x250 = x249 * x3
x251 = x248 + x250
x252 = x241 * x29
x253 = x240 * x53 + x52
x254 = x253 * x74
x255 = x214 * x241
x256 = x60 * (x238 * x6 - x255)
x257 = x252 * x3
x258 = x236 * x90 + x89
x259 = x6 * x60 * (-x237 * x7 + x258)
x260 = x60 * (x237 * x6 - x249 * x7)
x261 = x100 * x195 + x107
x262 = x100 * x199 + x101
x263 = x262 * x7
x264 = x263 * x3
x265 = x100 * x212 + x112
x266 = x140 * x265
x267 = x60 * (x261 - x263)
x268 = x100 * x194 + x142
x269 = x60 * (x100 * x218 + x141 - x268 * x7)
x270 = x60 * (-x261 * x7 + x268)
x271 = x157 + x180 * x193
x272 = x148 * x198 + x150
x273 = x272 * x7
x274 = x148 * x211 + x163
x275 = x60 * (x271 - x273)
x276 = x183 * x193 + x189
x277 = x60 * (x148 * x193 * x90 + x187 - x276 * x7)
x278 = x60 * (-x271 * x7 + x276)
x279 = x100 * x241
x280 = x279 * x7
x281 = x60 * (x100 * x238 - x280)
x282 = x100 * x253
x283 = x100 * x60 * (-x237 * x7 + x258)
x284 = x100 * x238
x285 = x60 * (x100 * x237 - x284 * x7)
x286 = x148 * x238 + x156
x287 = x148 * x241 + x149
x288 = x287 * x7
x289 = x288 * x3
x290 = x148 * x253 + x162
x291 = x140 * x290
x292 = x60 * (x286 - x288)
x293 = x148 * x237 + x188
x294 = x60 * (x148 * x258 + x186 - x293 * x7)
x295 = x60 * (-x286 * x7 + x293)
x296 = -x99 - A[1]
x297 = x296 * x47
x298 = x296 * x56
x299 = x296 * x58
x300 = x296 * x59
x301 = x4 * (x296 * x40 - x300)
x302 = x296 * x62
x303 = x296 * x66
x304 = x302 + x303
x305 = x296 * x4 * (x47 - x69)
x306 = x296 * x73
x307 = 0.06666666666666667 * x96
x308 = x108 * x296
x309 = x308 + x48
x310 = x72 * x81
x311 = x45 * x6
x312 = x100 * x296 * x311 + x310
x313 = x312 * x71
x314 = x102 * x296
x315 = x314 + x36
x316 = x72 * x78
x317 = x33 * x6
x318 = x100 * x296 * x317 + x316
x319 = x318 * x71
x320 = x113 * x296
x321 = x320 + x57
x322 = x63 * x72
x323 = x116 * x23
x324 = x296 * x323
x325 = x322 + x324
x326 = x325 * x71
x327 = x4 * (x309 - x315 * x7)
x328 = x131 * x296
x329 = x328 + x73
x330 = x29 * x329
x331 = x3 * x325 + x330
x332 = x4 * (x312 - x318 * x7)
x333 = 2.23606797749979 * x307
x334 = x296 * x4 * (x158 - x169)
x335 = x172 * x296
x336 = x173 * x296 + x335
x337 = x296 * x4 * (2.0 * x11 * x148 * x16 * x17 * x4 * x5 * x6 - x175)
x338 = x100 * x65
x339 = x194 * x296 + x31 * x338
x340 = x29 * x339
x341 = x207 * x296
x342 = x110 + x341
x343 = x17 * x338 + x195 * x296
x344 = x29 * x343
x345 = x199 * x296
x346 = x345 * x6
x347 = x104 + x346
x348 = x120 * x65
x349 = x345 + x348
x350 = x4 * (x339 - x343 * x7)
x351 = x29 * x349
x352 = x212 * x6
x353 = x296 * x352
x354 = x117 + x353
x355 = x4 * (x342 - x347 * x7)
x356 = x136 * x148
x357 = x182 + x296 * x356
x358 = x29 * x357
x359 = x148 * x316
x360 = x230 * x317
x361 = x296 * x360 + x359
x362 = x148 * x328 + x179
x363 = x29 * x362
x364 = x148 * x322
x365 = x148 * x324 + x364
x366 = x172 + x225 * x296
x367 = x4 * (x357 - x362 * x7)
x368 = x29 * x366
x369 = x148 * x167
x370 = x369 * x72
x371 = x23 * x231 * x6
x372 = x296 * x371 + x370
x373 = x4 * (x361 - x365 * x7)
x374 = 3.872983346207417
x375 = x307 * x374
x376 = x248 * x296
x377 = x245 * x296
x378 = x296 * x4 * (x237 - x239)
x379 = x252 * x296
x380 = x296 * x4 * (x238 * x6 - x255)
x381 = x261 * x296
x382 = 3.0 * x206
x383 = x381 + x382
x384 = x262 * x296
x385 = 3.0 * x203
x386 = x384 + x385
x387 = x386 * x7
x388 = x265 * x296
x389 = 3.0 * x210
x390 = x388 + x389
x391 = x4 * (x383 - x387)
x392 = x17 * x230 * x65
x393 = x271 * x296 + x392
x394 = x148 * x348
x395 = x272 * x296 + x394
x396 = x395 * x7
x397 = x115 * x166
x398 = x274 * x296 + x397
x399 = x4 * (x393 - x396)
x400 = x248 + x284 * x296
x401 = x245 + x279 * x296
x402 = x401 * x7
x403 = x252 + x282 * x296
x404 = x4 * (x400 - x402)
x405 = x296 * x4 * (x286 - x288)
x406 = -x147 - A[2]
x407 = x4 * x406 * (x40 - x59)
x408 = 0.5 * x407
x409 = x406 * (x62 + x66)
x410 = x4 * x406 * (x47 - x69)
x411 = 0.5 * x410
x412 = x406 * x73
x413 = x104 * x406
x414 = x110 * x406
x415 = x117 * x406
x416 = x4 * x406 * (x108 - x118)
x417 = 0.5 * x416
x418 = x121 * x406
x419 = x123 * x406 + x418
x420 = x4 * x406 * (2.0 * x100 * x11 * x16 * x17 * x4 * x5 * x6 - x126)
x421 = 0.5 * x420
x422 = x158 * x406 + x48
x423 = x148 * x311 * x406 + x310
x424 = x29 * x423
x425 = 2.0 * x424
x426 = x151 * x406 + x36
x427 = x148 * x406
x428 = x316 + x317 * x427
x429 = x29 * x428
x430 = 2.0 * x429
x431 = x164 * x406 + x57
x432 = x3 * x431
x433 = x23 * x369
x434 = x322 + x406 * x433
x435 = x29 * x434
x436 = 2.0 * x435
x437 = x426 * x7
x438 = x4 * (x422 - x437)
x439 = 0.5 * x438
x440 = x180 * x406 + x73
x441 = x29 * x440
x442 = x3 * x434
x443 = x441 + x442
x444 = x4 * (x423 - x428 * x7)
x445 = 0.5 * x444
x446 = x206 * x406
x447 = x203 * x406
x448 = x4 * x406 * (x194 - x196)
x449 = 0.5 * x448
x450 = x210 * x406
x451 = x4 * x406 * (x195 * x6 - x215)
x452 = 0.5 * x451
x453 = x135 + x356 * x406
x454 = x29 * x453
x455 = x100 * x316
x456 = x360 * x406 + x455
x457 = x130 + x131 * x427
x458 = x29 * x457
x459 = x100 * x322
x460 = x323 * x427 + x459
x461 = x121 + x225 * x406
x462 = x4 * (x453 - x457 * x7)
x463 = 0.5 * x462
x464 = x29 * x461
x465 = x116 * x72
x466 = x371 * x406 + x465
x467 = x4 * (x456 - x460 * x7)
x468 = 0.5 * x467
x469 = x166 * x31 + x237 * x406
x470 = x29 * x469
x471 = x160 + x249 * x406
x472 = x166 * x17 + x238 * x406
x473 = x29 * x472
x474 = x241 * x406
x475 = x153 + x474 * x6
x476 = x171 * x65 + x474
x477 = x4 * (x469 - x472 * x7)
x478 = 0.5 * x477
x479 = x29 * x476
x480 = x253 * x6
x481 = x168 + x406 * x480
x482 = x3 * x481
x483 = x475 * x7
x484 = x4 * (x471 - x483)
x485 = 0.5 * x484
x486 = x3 * x479
x487 = x4 * x406 * (x261 - x263)
x488 = 0.5 * x487
x489 = x206 + x271 * x406
x490 = x203 + x272 * x406
x491 = x490 * x7
x492 = x210 + x274 * x406
x493 = x4 * (x489 - x491)
x494 = 0.5 * x493
x495 = x284 * x406 + x392
x496 = x100 * x474 + x394
x497 = x496 * x7
x498 = x282 * x406 + x397
x499 = x4 * (x495 - x497)
x500 = 0.5 * x499
x501 = 3.0 * x248 + x286 * x406
x502 = 3.0 * x245 + x287 * x406
x503 = x502 * x7
x504 = 3.0 * x252 + x290 * x406
x505 = x140 * x504
x506 = x4 * (x501 - x503)
x507 = 0.5 * x506
x508 = x296**2
x509 = x508 * x55
x510 = x509 + x61
x511 = x26 * x508
x512 = x511 + x70
x513 = x29 * x512
x514 = x40 * x508 - x7 * (x27 * x508 + x94) + x93
x515 = x29 * (x317 * x508 + x85)
x516 = 0.02222222222222222 * x374 * x96
x517 = x296 * x57
x518 = x119 + x296 * x321 + x517
x519 = x296 * x322
x520 = x127 + x296 * x325 + x519
x521 = x520 * x71
x522 = x144 + x29 * x297 + x296 * x309 - x7 * (x145 + x296 * x315 + x296 * x36)
x523 = x29 * (x139 + x296 * x329 + x306)
x524 = 1.732050807568877
x525 = 0.1111111111111111 * x524 * x96
x526 = x164 * x508 + x170
x527 = x176 + x433 * x508
x528 = x29 * x527
x529 = x158 * x508 + x191 - x7 * (x151 * x508 + x192)
x530 = x29 * (x180 * x508 + x185)
x531 = x201 + x296 * x349 + 2.0 * x330
x532 = x29 * x531
x533 = x216 + x296 * x354 + x326
x534 = x219 + x296 * x342 + x313 - x7 * (x220 + x296 * x347 + x319)
x535 = x223 + x296 * x366 + x335
x536 = x29 * x535
x537 = x232 + x296 * x370 + x296 * x372
x538 = x233 + x296 * x359 + x296 * x361 - x7 * (x234 + x296 * x364 + x296 * x365)
x539 = 0.3333333333333333 * x96
x540 = x241 * x508
x541 = x243 + x540
x542 = x29 * x541
x543 = x256 + x480 * x508
x544 = x249 * x508 + x259 - x7 * (x260 + x540 * x6)
x545 = x267 + x296 * x390 + 3.0 * x351
x546 = x269 + x296 * x383 + 3.0 * x340 - x7 * (x270 + x296 * x386 + 3.0 * x344)
x547 = x275 + x296 * x398 + 2.0 * x368
x548 = x277 + x296 * x393 + 2.0 * x358 - x7 * (x278 + x296 * x395 + 2.0 * x363)
x549 = x281 + x296 * x403 + x379
x550 = x283 + x296 * x400 + x376 - x7 * (x285 + x296 * x401 + x377)
x551 = x290 * x508 + x292
x552 = x286 * x508 + x294 - x7 * (x287 * x508 + x295)
x553 = x4 * x406 * (x296 * x40 - x300)
x554 = x406 * x57
x555 = x320 * x406 + x554
x556 = x322 * x406
x557 = x324 * x406 + x556
x558 = x557 * x71
x559 = x406 * x48
x560 = x36 * x406
x561 = x4 * (x308 * x406 + x559 - x7 * (x314 * x406 + x560))
x562 = x29 * (x328 * x406 + x412)
x563 = x296 * x4 * (x422 - x437)
x564 = x296 * x441
x565 = x406 * (x345 + x348)
x566 = x29 * x565
x567 = x353 * x406 + x415
x568 = x4 * (x341 * x406 + x414 - x7 * (x346 * x406 + x413))
x569 = x296 * x461 + x441
x570 = x29 * x569
x571 = x296 * x466 + x435
x572 = x4 * (x296 * x456 + x424 - x7 * (x296 * x460 + x429))
x573 = x524 * x539
x574 = x296 * x479
x575 = x296 * x4 * (x471 - x483)
x576 = x406 * (x388 + x389)
x577 = x4 * x406 * (x381 + x382 - x7 * (x384 + x385))
x578 = 2.0 * x464
x579 = x296 * x492 + x578
x580 = 2.0 * x454
x581 = 2.0 * x458
x582 = x4 * (x296 * x489 + x580 - x7 * (x296 * x490 + x581))
x583 = x296 * x498 + x479
x584 = x4 * (x296 * x495 + x470 - x7 * (x296 * x496 + x473))
x585 = x296 * x4 * (x501 - x503)
x586 = x406**2
x587 = x55 * x586 + x61
x588 = x3 * x587
x589 = x26 * x586 + x70
x590 = x29 * x589
x591 = 3.0 * x590
x592 = x40 * x586 - x7 * (x27 * x586 + x94) + x93
x593 = x592 * x60
x594 = x29 * (x317 * x586 + x85)
x595 = x113 * x586 + x119
x596 = x127 + x323 * x586
x597 = x29 * x596
x598 = 2.0 * x597
x599 = x108 * x586 + x144 - x7 * (x102 * x586 + x145)
x600 = x599 * x60
x601 = x29 * (x131 * x586 + x139)
x602 = x170 + x406 * x431 + x554
x603 = x3 * x602
x604 = x176 + x406 * x434 + x556
x605 = x29 * x604
x606 = 2.0 * x605
x607 = x191 + x406 * x422 + x559 - x7 * (x192 + x406 * x426 + x560)
x608 = x60 * x607
x609 = x29 * (x185 + x406 * x440 + x412)
x610 = x199 * x586
x611 = x201 + x610
x612 = x29 * x611
x613 = x216 + x352 * x586
x614 = x207 * x586 + x219 - x7 * (x220 + x6 * x610)
x615 = x60 * x614
x616 = x223 + x406 * x461 + x418
x617 = x29 * x616
x618 = x232 + x406 * x465 + x406 * x466
x619 = x233 + x406 * x455 + x406 * x456 - x7 * (x234 + x406 * x459 + x406 * x460)
x620 = x60 * x619
x621 = x243 + x406 * x476 + 2.0 * x441
x622 = x29 * x621
x623 = x256 + x406 * x481 + x436
x624 = x3 * x623
x625 = x259 + x406 * x471 + x425 - x7 * (x260 + x406 * x475 + x430)
x626 = x60 * x625
x627 = x265 * x586 + x267
x628 = x261 * x586 + x269 - x7 * (x262 * x586 + x270)
x629 = x60 * x628
x630 = x275 + x406 * x492 + x450
x631 = x277 + x406 * x489 + x446 - x7 * (x278 + x406 * x490 + x447)
x632 = x60 * x631
x633 = x281 + x406 * x498 + x578
x634 = x283 + x406 * x495 + x580 - x7 * (x285 + x406 * x496 + x581)
x635 = x60 * x634
x636 = x292 + x406 * x504 + 3.0 * x479
x637 = x294 + x406 * x501 + 3.0 * x470 - x7 * (x295 + x406 * x502 + 3.0 * x473)
x638 = x60 * x637
x639 = x296 * x510 + x301
x640 = x29 * (x296 * x512 + x305)
x641 = x296 * x518 + x327 + x513
x642 = x71 * (x296 * x520 + x332 + x515)
x643 = x296 * x526 + x334
x644 = x29 * (x296 * x527 + x337)
x645 = x29 * (x296 * x531 + x350 + 2.0 * x523)
x646 = x296 * x533 + x355 + x521
x647 = x29 * (x296 * x535 + x367 + x530)
x648 = x296 * x537 + x373 + x528
x649 = x29 * (x296 * x541 + x378)
x650 = x296 * x543 + x380
x651 = x296 * x545 + x391 + 3.0 * x532
x652 = x3 * x307
x653 = x296 * x547 + x399 + 2.0 * x536
x654 = x3 * x333
x655 = x296 * x549 + x404 + x542
x656 = x296 * x551 + x405
x657 = x406 * x509 + x408
x658 = x29 * (x406 * x511 + x411)
x659 = x296 * x555 + x406 * x517 + x417
x660 = x71 * (x296 * x557 + x406 * x519 + x421)
x661 = x431 * x508 + x439
x662 = x29 * (x434 * x508 + x445)
x663 = x29 * (x296 * x565 + x449 + 2.0 * x562)
x664 = x296 * x567 + x452 + x558
x665 = x29 * (x296 * x569 + x463 + x564)
x666 = x296 * x435 + x296 * x571 + x468
x667 = x29 * (x476 * x508 + x478)
x668 = x481 * x508 + x485
x669 = x296 * x576 + x488 + 3.0 * x566
x670 = x296 * x579 + x494 + 2.0 * x570
x671 = x3 * x539
x672 = x296 * x583 + x500 + x574
x673 = x504 * x508 + x507
x674 = x296 * x595 + x590
x675 = x71 * (x296 * x596 + x594)
x676 = x29 * (x296 * x611 + 2.0 * x601)
x677 = x296 * x613 + x598
x678 = x29 * (x296 * x616 + x609)
x679 = x296 * x618 + x605
x680 = x296 * x622
x681 = x296 * x627 + 3.0 * x612
x682 = 2.0 * x617
x683 = x296 * x630 + x682
x684 = x296 * x633 + x622
x685 = x406 * x587 + x407
x686 = x29 * (x406 * x589 + x410)
x687 = x406 * x595 + x416
x688 = x29 * (x406 * x596 + x420)
x689 = 2.0 * x688
x690 = x406 * x602 + x438 + x590
x691 = x29 * (x406 * x604 + x444 + x594)
x692 = 2.0 * x691
x693 = x29 * (x406 * x611 + x448)
x694 = x406 * x613 + x451
x695 = x29 * (x406 * x616 + x462 + x601)
x696 = x406 * x618 + x467 + x597
x697 = x29 * (x406 * x621 + x477 + 2.0 * x609)
x698 = x406 * x623 + x484 + x606
x699 = x406 * x627 + x487
x700 = x406 * x630 + x493 + x612
x701 = x406 * x633 + x499 + x682
x702 = x406 * x636 + x506 + 3.0 * x622
x703 = x296 * x307
x704 = x296 * x333
x705 = 2.0 * x695
# 150 item(s)
result[0, 0] = numpy.sum(
x98
* (
x3
* (
x3 * (x3 * (x56 + x58) + x61 + x67 * x68)
- x4 * (x38 * x7 - x50)
+ x68 * x77
)
+ x68 * (x3 * x77 - x4 * (x7 * x80 - x82) + x71 * (x3 * x76 + x85 + x86))
+ x95 * (x3 * x50 + x68 * x82 - x7 * (x3 * x38 + x68 * x80 + x94) + x93)
)
)
result[0, 1] = numpy.sum(
x146
* (
x3
* (
x129 * x71
+ x3 * (x119 + x124 * x71 + x3 * (x114 + x117))
- x4 * (x105 * x7 - x111)
)
+ x71 * (x129 * x3 + x29 * (x131 * x140 + x139) - x4 * (x133 * x7 - x137))
+ x95 * (x111 * x3 + x137 * x71 + x144 - x7 * (x105 * x3 + x133 * x71 + x145))
)
)
result[0, 2] = numpy.sum(
x146
* (
x3
* (
x178 * x71
+ x3 * (x170 + x174 * x71 + x3 * (x165 + x168))
- x4 * (x154 * x7 - x161)
)
+ x71 * (x178 * x3 + x29 * (x140 * x180 + x185) - x4 * (x181 * x7 - x184))
+ x95 * (x161 * x3 + x184 * x71 + x191 - x7 * (x154 * x3 + x181 * x71 + x192))
)
)
result[0, 3] = numpy.sum(
x146
* (
x29 * x3 * (x202 + x4 * (x194 - x196))
+ x3
* (
x202 * x29
+ x3 * (x216 + x217 + x3 * (x210 + x213))
- x4 * (x205 * x7 - x209)
)
+ x95
* (x194 * x29 * x3 + x209 * x3 + x219 - x7 * (x203 * x3 + x205 * x3 + x220))
)
)
result[0, 4] = numpy.sum(
x235
* (
x29
* x3
* (x226 + x4 * (2.0 * x100 * x11 * x148 * x16 * x17 * x4 * x5 - x222))
+ x3
* (
x226 * x29
+ x3 * (x229 * x3 + x232 + x3 * (x122 * x231 + x229))
- x4 * (x227 * x7 - x228)
)
+ x95
* (x228 * x3 + x230 * x86 + x233 - x7 * (x128 * x148 + x227 * x3 + x234))
)
)
result[0, 5] = numpy.sum(
x146
* (
x29 * x3 * (x244 + x4 * (x237 - x239))
+ x3
* (
x244 * x29
+ x3 * (x256 + x257 + x3 * (x252 + x254))
- x4 * (x247 * x7 - x251)
)
+ x95
* (x237 * x29 * x3 + x251 * x3 + x259 - x7 * (x245 * x3 + x247 * x3 + x260))
)
)
result[0, 6] = numpy.sum(
x98
* (
x3 * (x3 * (x266 + x267) + x4 * (x261 * x3 - x264))
+ x95 * (x140 * x261 + x269 - x7 * (x140 * x262 + x270))
)
)
result[0, 7] = numpy.sum(
x146
* (
x3**2 * (x140 * x274 + x275 + x4 * (x271 - x273))
+ x95 * (x140 * x271 + x277 - x7 * (x140 * x272 + x278))
)
)
result[0, 8] = numpy.sum(
x146
* (
x3**2 * (x140 * x282 + x281 + x4 * (x100 * x238 - x280))
+ x95 * (x140 * x284 + x283 - x7 * (x100 * x242 + x285))
)
)
result[0, 9] = numpy.sum(
x98
* (
x3 * (x3 * (x291 + x292) + x4 * (x286 * x3 - x289))
+ x95 * (x140 * x286 + x294 - x7 * (x140 * x287 + x295))
)
)
result[1, 0] = numpy.sum(
0.5
* x307
* (
x3 * (2.0 * x3 * (x298 + x299) + x301 + 2.0 * x304 * x68)
+ 2.0 * x4 * (x296 * x41 - x296 * x7 * (x28 + x37) + x297 * x68)
+ x68 * (2.0 * x3 * x304 + x305 + 2.0 * x71 * (x296 * x75 + x306))
)
)
result[1, 1] = numpy.sum(
0.5
* x333
* (
x3 * (2.0 * x3 * (x3 * x321 + x326) + x327 + 2.0 * x331 * x71)
+ 2.0 * x4 * (x3 * x309 + x313 - x7 * (x3 * x315 + x319))
+ x71 * (2.0 * x3 * x330 + 2.0 * x3 * x331 + x332)
)
)
result[1, 2] = numpy.sum(
0.5
* x333
* (
2.0 * x296 * x4 * (x159 + x160 - x7 * (x152 + x153))
+ x3 * (2.0 * x296 * x3 * (x165 + x168) + x334 + 2.0 * x336 * x71)
+ x71 * (2.0 * x177 * x296 + 2.0 * x3 * x336 + x337)
)
)
result[1, 3] = numpy.sum(
0.5
* x333
* (
x29 * (2.0 * x140 * x349 + x350)
+ x3 * (2.0 * x3 * x351 + 2.0 * x3 * (x3 * x354 + x351) + x355)
+ 2.0 * x4 * (x3 * x342 + x340 - x7 * (x3 * x347 + x344))
)
)
result[1, 4] = numpy.sum(
0.5
* x375
* (
x29 * (2.0 * x140 * x366 + x367)
+ x3 * (2.0 * x3 * x368 + 2.0 * x3 * (x3 * x372 + x368) + x373)
+ 2.0 * x4 * (x3 * x361 + x358 - x7 * (x3 * x365 + x363))
)
)
result[1, 5] = numpy.sum(
0.5
* x333
* (
x29 * (2.0 * x242 * x296 + x378)
+ x3 * (2.0 * x257 * x296 + 2.0 * x3 * (x254 * x296 + x379) + x380)
+ 2.0 * x4 * (x250 * x296 + x376 - x7 * (x246 * x296 + x377))
)
)
result[1, 6] = numpy.sum(
0.5 * x3 * x307 * (2.0 * x140 * x390 + x391 + 2.0 * x4 * (x383 - x387))
)
result[1, 7] = numpy.sum(
0.5 * x3 * x333 * (2.0 * x140 * x398 + x399 + 2.0 * x4 * (x393 - x396))
)
result[1, 8] = numpy.sum(
0.5 * x3 * x333 * (2.0 * x140 * x403 + 2.0 * x4 * (x400 - x402) + x404)
)
result[1, 9] = numpy.sum(
0.5
* x307
* (2.0 * x296 * x4 * (x286 * x3 - x289) + x3 * (2.0 * x291 * x296 + x405))
)
result[2, 0] = numpy.sum(
x307
* (
x3 * (x3 * x406 * (x56 + x58) + x408 + x409 * x68)
+ x4 * x406 * (x41 + x49 - x7 * (x28 + x37))
+ x68 * (x3 * x409 + x411 + x71 * (x406 * x75 + x412))
)
)
result[2, 1] = numpy.sum(
x333
* (
x3 * (x3 * (x114 * x406 + x415) + x417 + x419 * x71)
+ x4 * (x109 * x406 + x414 - x7 * (x103 * x406 + x413))
+ x71 * (x128 * x406 + x3 * x419 + x421)
)
)
result[2, 2] = numpy.sum(
x333
* (
x3 * (x3 * (x432 + x436) + x439 + x443 * x71)
+ x4 * (x3 * x422 + x425 - x7 * (x3 * x426 + x430))
+ x71 * (x3 * x441 + x3 * x443 + x445)
)
)
result[2, 3] = numpy.sum(
x333
* (
x29 * (x200 * x406 + x449)
+ x3 * (x217 * x406 + x3 * (x213 * x406 + x450) + x452)
+ x4 * (x208 * x406 + x446 - x7 * (x204 * x406 + x447))
)
)
result[2, 4] = numpy.sum(
x375
* (
x29 * (x140 * x461 + x463)
+ x3 * (x3 * x464 + x3 * (x3 * x466 + x464) + x468)
+ x4 * (x3 * x456 + x454 - x7 * (x3 * x460 + x458))
)
)
result[2, 5] = numpy.sum(
x333
* (
x29 * (x140 * x476 + x478)
+ x3 * (x3 * (x479 + x482) + x485 + x486)
+ x4 * (x3 * x471 + x470 - x7 * (x3 * x475 + x473))
)
)
result[2, 6] = numpy.sum(
x307 * (x3 * (x266 * x406 + x488) + x4 * x406 * (x261 * x3 - x264))
)
result[2, 7] = numpy.sum(x3 * x333 * (x140 * x492 + x4 * (x489 - x491) + x494))
result[2, 8] = numpy.sum(x3 * x333 * (x140 * x498 + x4 * (x495 - x497) + x500))
result[2, 9] = numpy.sum(x3 * x307 * (x4 * (x501 - x503) + x505 + x507))
result[3, 0] = numpy.sum(
x516
* (x3 * (x3 * x510 + 3.0 * x513) + x514 * x60 + x68 * (x3 * x512 + 2.0 * x515))
)
result[3, 1] = numpy.sum(
x525 * (x3 * (x3 * x518 + x521) + x522 * x60 + x71 * (x3 * x520 + x523))
)
result[3, 2] = numpy.sum(
x525 * (x3 * (x3 * x526 + 2.0 * x528) + x529 * x60 + x71 * (x3 * x527 + x530))
)
result[3, 3] = numpy.sum(x525 * (x3 * x532 + x3 * (x3 * x533 + x532) + x534 * x60))
result[3, 4] = numpy.sum(x539 * (x3 * x536 + x3 * (x3 * x537 + x536) + x538 * x60))
result[3, 5] = numpy.sum(x525 * (x3 * x542 + x3 * (x3 * x543 + x542) + x544 * x60))
result[3, 6] = numpy.sum(x516 * (x140 * x545 + x546 * x60))
result[3, 7] = numpy.sum(x525 * (x140 * x547 + x548 * x60))
result[3, 8] = numpy.sum(x525 * (x140 * x549 + x550 * x60))
result[3, 9] = numpy.sum(x516 * (x140 * x551 + x552 * x60))
result[4, 0] = numpy.sum(
0.5
* x333
* (2.0 * x3 * x406 * (x298 + x299) + 2.0 * x406 * x68 * (x302 + x303) + x553)
)
result[4, 1] = numpy.sum(
0.5
* x539
* (2.0 * x3 * (x3 * x555 + x558) + x561 + 2.0 * x71 * (x3 * x557 + x562))
)
result[4, 2] = numpy.sum(
0.5
* x539
* (2.0 * x296 * x3 * (x432 + x436) + x563 + 2.0 * x71 * (x296 * x442 + x564))
)
result[4, 3] = numpy.sum(0.5 * x539 * (2.0 * x3**2 * x567 + 4.0 * x3 * x566 + x568))
result[4, 4] = numpy.sum(0.5 * x573 * (2.0 * x3**2 * x571 + 4.0 * x3 * x570 + x572))
result[4, 5] = numpy.sum(
0.5 * x539 * (2.0 * x296 * x486 + 2.0 * x3 * (x296 * x482 + x574) + x575)
)
result[4, 6] = numpy.sum(0.5 * x333 * (2.0 * x140 * x576 + x577))
result[4, 7] = numpy.sum(0.5 * x539 * (2.0 * x140 * x579 + x582))
result[4, 8] = numpy.sum(0.5 * x539 * (2.0 * x140 * x583 + x584))
result[4, 9] = numpy.sum(0.5 * x333 * (2.0 * x296 * x505 + x585))
result[5, 0] = numpy.sum(
x516 * (x3 * (x588 + x591) + x593 + x68 * (x3 * x589 + 2.0 * x594))
)
result[5, 1] = numpy.sum(
x525 * (x3 * (x3 * x595 + x598) + x600 + x71 * (x3 * x596 + x601))
)
result[5, 2] = numpy.sum(
x525 * (x3 * (x603 + x606) + x608 + x71 * (x3 * x604 + x609))
)
result[5, 3] = numpy.sum(x525 * (x3 * x612 + x3 * (x3 * x613 + x612) + x615))
result[5, 4] = numpy.sum(x539 * (x3 * x617 + x3 * (x3 * x618 + x617) + x620))
result[5, 5] = numpy.sum(x525 * (x3 * x622 + x3 * (x622 + x624) + x626))
result[5, 6] = numpy.sum(x516 * (x140 * x627 + x629))
result[5, 7] = numpy.sum(x525 * (x140 * x630 + x632))
result[5, 8] = numpy.sum(x525 * (x140 * x633 + x635))
result[5, 9] = numpy.sum(x516 * (x140 * x636 + x638))
result[6, 0] = numpy.sum(x307 * (x3 * x639 + 3.0 * x640))
result[6, 1] = numpy.sum(x333 * (x3 * x641 + x642))
result[6, 2] = numpy.sum(x333 * (x3 * x643 + 2.0 * x644))
result[6, 3] = numpy.sum(x333 * (x3 * x646 + x645))
result[6, 4] = numpy.sum(x375 * (x3 * x648 + x647))
result[6, 5] = numpy.sum(x333 * (x3 * x650 + x649))
result[6, 6] = numpy.sum(x651 * x652)
result[6, 7] = numpy.sum(x653 * x654)
result[6, 8] = numpy.sum(x654 * x655)
result[6, 9] = numpy.sum(x652 * x656)
result[7, 0] = numpy.sum(x333 * (x3 * x657 + 3.0 * x658))
result[7, 1] = numpy.sum(x539 * (x3 * x659 + x660))
result[7, 2] = numpy.sum(x539 * (x3 * x661 + 2.0 * x662))
result[7, 3] = numpy.sum(x539 * (x3 * x664 + x663))
result[7, 4] = numpy.sum(x573 * (x3 * x666 + x665))
result[7, 5] = numpy.sum(x539 * (x3 * x668 + x667))
result[7, 6] = numpy.sum(x654 * x669)
result[7, 7] = numpy.sum(x670 * x671)
result[7, 8] = numpy.sum(x671 * x672)
result[7, 9] = numpy.sum(x654 * x673)
result[8, 0] = numpy.sum(x296 * x333 * (x588 + x591))
result[8, 1] = numpy.sum(x539 * (x3 * x674 + x675))
result[8, 2] = numpy.sum(x296 * x539 * (x603 + x606))
result[8, 3] = numpy.sum(x539 * (x3 * x677 + x676))
result[8, 4] = numpy.sum(x573 * (x3 * x679 + x678))
result[8, 5] = numpy.sum(x539 * (x296 * x624 + x680))
result[8, 6] = numpy.sum(x654 * x681)
result[8, 7] = numpy.sum(x671 * x683)
result[8, 8] = numpy.sum(x671 * x684)
result[8, 9] = numpy.sum(x296 * x636 * x654)
result[9, 0] = numpy.sum(x307 * (x3 * x685 + 3.0 * x686))
result[9, 1] = numpy.sum(x333 * (x3 * x687 + x689))
result[9, 2] = numpy.sum(x333 * (x3 * x690 + x692))
result[9, 3] = numpy.sum(x333 * (x3 * x694 + x693))
result[9, 4] = numpy.sum(x375 * (x3 * x696 + x695))
result[9, 5] = numpy.sum(x333 * (x3 * x698 + x697))
result[9, 6] = numpy.sum(x652 * x699)
result[9, 7] = numpy.sum(x654 * x700)
result[9, 8] = numpy.sum(x654 * x701)
result[9, 9] = numpy.sum(x652 * x702)
result[10, 0] = numpy.sum(x98 * (x296 * x639 + x514 * x95))
result[10, 1] = numpy.sum(x146 * (x296 * x641 + x522 * x95 + x640))
result[10, 2] = numpy.sum(x146 * (x296 * x643 + x529 * x95))
result[10, 3] = numpy.sum(x146 * (x296 * x646 + x534 * x95 + x642))
result[10, 4] = numpy.sum(x235 * (x296 * x648 + x538 * x95 + x644))
result[10, 5] = numpy.sum(x146 * (x296 * x650 + x544 * x95))
result[10, 6] = numpy.sum(x98 * (x296 * x651 + x546 * x95 + 3.0 * x645))
result[10, 7] = numpy.sum(x146 * (x296 * x653 + x548 * x95 + 2.0 * x647))
result[10, 8] = numpy.sum(x146 * (x296 * x655 + x550 * x95 + x649))
result[10, 9] = numpy.sum(x98 * (x296 * x656 + x552 * x95))
result[11, 0] = numpy.sum(x307 * (x296 * x657 + x553))
result[11, 1] = numpy.sum(x333 * (x296 * x659 + x561 + x658))
result[11, 2] = numpy.sum(x333 * (x296 * x661 + x563))
result[11, 3] = numpy.sum(x333 * (x296 * x664 + x568 + x660))
result[11, 4] = numpy.sum(x375 * (x296 * x666 + x572 + x662))
result[11, 5] = numpy.sum(x333 * (x296 * x668 + x575))
result[11, 6] = numpy.sum(x307 * (x296 * x669 + x577 + 3.0 * x663))
result[11, 7] = numpy.sum(x333 * (x296 * x670 + x582 + 2.0 * x665))
result[11, 8] = numpy.sum(x333 * (x296 * x672 + x584 + x667))
result[11, 9] = numpy.sum(x307 * (x296 * x673 + x585))
result[12, 0] = numpy.sum(x516 * (x508 * x587 + x593))
result[12, 1] = numpy.sum(x525 * (x296 * x590 + x296 * x674 + x600))
result[12, 2] = numpy.sum(x525 * (x508 * x602 + x608))
result[12, 3] = numpy.sum(x525 * (x296 * x677 + x615 + x675))
result[12, 4] = numpy.sum(x539 * (x296 * x605 + x296 * x679 + x620))
result[12, 5] = numpy.sum(x525 * (x508 * x623 + x626))
result[12, 6] = numpy.sum(x516 * (x296 * x681 + x629 + 3.0 * x676))
result[12, 7] = numpy.sum(x525 * (x296 * x683 + x632 + 2.0 * x678))
result[12, 8] = numpy.sum(x525 * (x296 * x684 + x635 + x680))
result[12, 9] = numpy.sum(x516 * (x508 * x636 + x638))
result[13, 0] = numpy.sum(x685 * x703)
result[13, 1] = numpy.sum(x333 * (x296 * x687 + x686))
result[13, 2] = numpy.sum(x690 * x704)
result[13, 3] = numpy.sum(x333 * (x296 * x694 + x689))
result[13, 4] = numpy.sum(x375 * (x296 * x696 + x691))
result[13, 5] = numpy.sum(x698 * x704)
result[13, 6] = numpy.sum(x307 * (x296 * x699 + 3.0 * x693))
result[13, 7] = numpy.sum(x333 * (x296 * x700 + x705))
result[13, 8] = numpy.sum(x333 * (x296 * x701 + x697))
result[13, 9] = numpy.sum(x702 * x703)
result[14, 0] = numpy.sum(x98 * (x406 * x685 + x592 * x95))
result[14, 1] = numpy.sum(x146 * (x406 * x687 + x599 * x95))
result[14, 2] = numpy.sum(x146 * (x406 * x690 + x607 * x95 + x686))
result[14, 3] = numpy.sum(x146 * (x406 * x694 + x614 * x95))
result[14, 4] = numpy.sum(x235 * (x406 * x696 + x619 * x95 + x688))
result[14, 5] = numpy.sum(x146 * (x406 * x698 + x625 * x95 + x692))
result[14, 6] = numpy.sum(x98 * (x406 * x699 + x628 * x95))
result[14, 7] = numpy.sum(x146 * (x406 * x700 + x631 * x95 + x693))
result[14, 8] = numpy.sum(x146 * (x406 * x701 + x634 * x95 + x705))
result[14, 9] = numpy.sum(x98 * (x406 * x702 + x637 * x95 + 3.0 * x697))
return result
[docs]
def int2c2e3d_44(ax, da, A, bx, db, B):
"""Cartesian (g|g) two-center two-electron repulsion integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((15, 15), dtype=float)
x0 = ax + bx
x1 = x0 ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - A[0]
x4 = ax ** (-1.0)
x5 = -x2 - B[0]
x6 = bx ** (-1.0)
x7 = ax * x1
x8 = bx * x7 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2)
x9 = boys(6, x8)
x10 = x0 ** (-1.5)
x11 = 17.49341832762486
x12 = x11 * x6
x13 = 2.0 * x12
x14 = x10 * x13
x15 = x14 * x9
x16 = x15 * x5
x17 = x0 ** (-0.5)
x18 = boys(5, x8)
x19 = 0.5 * x6
x20 = x19 * (2.0 * x11 * x17 * x18 * x4 * x6 - x15)
x21 = boys(7, x8)
x22 = x5**2
x23 = x17 * x4
x24 = x13 * x23
x25 = x22 * x24
x26 = x21 * x25
x27 = x20 + x26
x28 = x27 * x5 + x6 * (2.0 * x11 * x17 * x18 * x4 * x5 * x6 - x16)
x29 = x14 * x18
x30 = boys(4, x8)
x31 = x19 * (2.0 * x11 * x17 * x30 * x4 * x6 - x29)
x32 = x24 * x9
x33 = x22 * x32
x34 = x31 + x33
x35 = x14 * x30
x36 = boys(3, x8)
x37 = x19 * (2.0 * x11 * x17 * x36 * x4 * x6 - x35)
x38 = x18 * x24
x39 = x22 * x38
x40 = x37 + x39
x41 = 1.5 * x6
x42 = x28 * x5 - x41 * (x34 * x7 - x40)
x43 = x3 * x42
x44 = 0.5 / (ax + bx)
x45 = x29 * x5
x46 = x34 * x5 + x6 * (2.0 * x11 * x17 * x30 * x4 * x5 * x6 - x45)
x47 = x44 * x46
x48 = 4.0 * x47
x49 = x43 + x48
x50 = bx * x1
x51 = x14 * x36
x52 = boys(2, x8)
x53 = x19 * (2.0 * x11 * x17 * x4 * x52 * x6 - x51)
x54 = x24 * x30
x55 = x22 * x54
x56 = x53 + x55
x57 = -x41 * (x40 * x7 - x56) + x46 * x5
x58 = x3 * x57
x59 = x35 * x5
x60 = x40 * x5 + x6 * (2.0 * x11 * x17 * x36 * x4 * x5 * x6 - x59)
x61 = x44 * x60
x62 = 4.0 * x61
x63 = x58 + x62
x64 = x14 * x21
x65 = x5 * x64
x66 = x19 * (2.0 * x11 * x17 * x4 * x6 * x9 - x64)
x67 = boys(8, x8)
x68 = x25 * x67
x69 = -x41 * (x27 * x7 - x34) + x5 * (
x5 * (x66 + x68) + x6 * (2.0 * x11 * x17 * x4 * x5 * x6 * x9 - x65)
)
x70 = x3 * x69
x71 = x28 * x44
x72 = 4.0 * x71
x73 = x42 * x50
x74 = 0.5 * x4
x75 = x74 * (x57 - x73)
x76 = x28 * x3
x77 = x34 * x44
x78 = 3.0 * x77
x79 = x76 + x78
x80 = 4.0 * x44
x81 = x46 * x50
x82 = x74 * (x60 - x81)
x83 = x3 * x34
x84 = x18 * x5
x85 = x12 * x23
x86 = x80 * x85
x87 = x84 * x86
x88 = x83 + x87
x89 = 3.0 * x44
x90 = x3 * x79 + x82 + x88 * x89
x91 = x40 * x44
x92 = x3 * x46 + 3.0 * x91
x93 = x44 * x56
x94 = x3 * x60 + 3.0 * x93
x95 = x74 * (-x40 * x50 + x56)
x96 = 2.0 * x44
x97 = x85 * x96
x98 = x30 * x97
x99 = x3 * x5
x100 = x5 * x51
x101 = boys(1, x8)
x102 = x19 * (-x101 * x14 + 2.0 * x11 * x17 * x4 * x6 * boys(0, x8))
x103 = x19 * (2.0 * x101 * x11 * x17 * x4 * x6 - x14 * x52)
x104 = x24 * x36
x105 = x103 + x104 * x22
x106 = x24 * x52
x107 = x41 * (x105 - x56 * x7) + x5 * x60
x108 = x74 * (
-x107 * x50
+ x41 * (x102 - x105 * x7 + x106 * x22)
+ x5 * (x5 * x56 - x6 * (x100 - 2.0 * x11 * x17 * x4 * x5 * x52 * x6))
)
x109 = x74 * (x107 - x50 * x57)
x110 = 1.5 * x4
x111 = da * db
x112 = 0.009523809523809524 * x111
x113 = -x1 * (ax * A[1] + bx * B[1])
x114 = -x113 - B[1]
x115 = x114 * x5
x116 = x114 * x15
x117 = x6 * (2.0 * x11 * x114 * x17 * x18 * x4 * x6 - x116)
x118 = x114 * x26
x119 = 0.5 * x117 + x118
x120 = x119 * x5 + x6 * (2.0 * x11 * x114 * x17 * x18 * x4 * x5 * x6 - x115 * x15)
x121 = x120 * x3
x122 = x114 * x29
x123 = x6 * (2.0 * x11 * x114 * x17 * x30 * x4 * x6 - x122)
x124 = x114 * x33
x125 = 0.5 * x123 + x124
x126 = x125 * x44
x127 = 3.0 * x126
x128 = x121 + x127
x129 = -2.0 * x11 * x114 * x17 * x30 * x4 * x5 * x6
x130 = x125 * x5 - x6 * (x115 * x29 + x129)
x131 = x130 * x3
x132 = x114 * x35
x133 = x6 * (2.0 * x11 * x114 * x17 * x36 * x4 * x6 - x132)
x134 = x114 * x39
x135 = 0.5 * x133 + x134
x136 = x135 * x44
x137 = x131 + 3.0 * x136
x138 = x114 * x64
x139 = x6 * (2.0 * x11 * x114 * x17 * x4 * x6 * x9 - x138)
x140 = x114 * x68
x141 = 0.5 * x5 * (x139 + 2.0 * x140) + x6 * (
2.0 * x11 * x114 * x17 * x4 * x5 * x6 * x9 - x115 * x64
)
x142 = x141 * x3
x143 = x119 * x44
x144 = 3.0 * x143
x145 = x120 * x50
x146 = x74 * (x130 - x145)
x147 = x119 * x3
x148 = x115 * x9
x149 = x148 * x86
x150 = x147 + x149
x151 = x125 * x50
x152 = x74 * (x135 - x151)
x153 = x114 * x18
x154 = x153 * x97
x155 = x114 * x99
x156 = x155 * x32
x157 = x154 + x156
x158 = x150 * x3 + x152 + x157 * x96
x159 = x115 * x18
x160 = x159 * x86
x161 = x125 * x3 + x160
x162 = x30 * x86
x163 = x115 * x162
x164 = x135 * x3 + x163
x165 = 2.0 * x10 * x11 * x4
x166 = -x74 * (x129 + x159 * x165)
x167 = x114 * x51
x168 = x6 * (2.0 * x11 * x114 * x17 * x4 * x52 * x6 - x167)
x169 = x114 * x55
x170 = x135 * x5 + x6 * (2.0 * x11 * x114 * x17 * x36 * x4 * x5 * x6 - x115 * x35)
x171 = (
0.5
* x74
* (
-2.0 * x170 * x50
+ x5 * (x168 + 2.0 * x169)
+ 2.0 * x6 * (2.0 * x11 * x114 * x17 * x4 * x5 * x52 * x6 - x115 * x51)
)
)
x172 = x74 * (-x130 * x50 + x170)
x173 = 2.645751311064591 * x112
x174 = -x1 * (ax * A[2] + bx * B[2])
x175 = -x174 - B[2]
x176 = x175 * x6 * (2.0 * x11 * x17 * x18 * x4 * x6 - x15)
x177 = 0.5 * x176
x178 = x175 * x26 + x177
x179 = x175 * x6 * (2.0 * x11 * x17 * x18 * x4 * x5 * x6 - x16) + x178 * x5
x180 = x179 * x3
x181 = x175 * x6 * (2.0 * x11 * x17 * x30 * x4 * x6 - x29)
x182 = 0.5 * x181
x183 = x175 * x33 + x182
x184 = x183 * x44
x185 = 3.0 * x184
x186 = x180 + x185
x187 = -2.0 * x11 * x17 * x175 * x30 * x4 * x5 * x6
x188 = x183 * x5 - x6 * (x175 * x45 + x187)
x189 = x188 * x3
x190 = x175 * x6 * (2.0 * x11 * x17 * x36 * x4 * x6 - x35)
x191 = 0.5 * x190
x192 = x175 * x39 + x191
x193 = x192 * x44
x194 = x189 + 3.0 * x193
x195 = x175 * x6 * (2.0 * x11 * x17 * x4 * x6 * x9 - x64)
x196 = 0.5 * x195
x197 = x175 * x6 * (2.0 * x11 * x17 * x4 * x5 * x6 * x9 - x65) + x5 * (
x175 * x68 + x196
)
x198 = x197 * x3
x199 = x178 * x44
x200 = 3.0 * x199
x201 = x179 * x50
x202 = x74 * (x188 - x201)
x203 = x178 * x3
x204 = x175 * x5
x205 = x204 * x9
x206 = x205 * x86
x207 = x203 + x206
x208 = x183 * x50
x209 = x74 * (x192 - x208)
x210 = x175 * x18
x211 = x210 * x97
x212 = x175 * x32
x213 = x212 * x99
x214 = x211 + x213
x215 = x207 * x3 + x209 + x214 * x96
x216 = x175 * x87
x217 = x183 * x3 + x216
x218 = x162 * x204
x219 = x192 * x3 + x218
x220 = x165 * x175
x221 = -x74 * (x187 + x220 * x84)
x222 = x175 * x6 * (2.0 * x11 * x17 * x4 * x52 * x6 - x51)
x223 = 0.5 * x222
x224 = x175 * x6 * (2.0 * x11 * x17 * x36 * x4 * x5 * x6 - x59) + x192 * x5
x225 = -x74 * (
x175 * x6 * (x100 - 2.0 * x11 * x17 * x4 * x5 * x52 * x6)
+ x224 * x50
- x5 * (x175 * x55 + x223)
)
x226 = x74 * (-x188 * x50 + x224)
x227 = x114**2
x228 = x227 * x24
x229 = x21 * x228
x230 = x20 + x229
x231 = x227 * x32 + x31
x232 = x227 * x38 + x37
x233 = -x231 * x7 + x232
x234 = x19 * x233 + x22 * x230
x235 = x234 * x3
x236 = x231 * x44
x237 = x236 * x5
x238 = x235 + 2.0 * x237
x239 = x227 * x54 + x53
x240 = -x232 * x7 + x239
x241 = x19 * x240 + x22 * x231
x242 = x241 * x3
x243 = x232 * x5
x244 = x242 + x243 * x96
x245 = x228 * x67
x246 = x245 + x66
x247 = -x230 * x7 + x231
x248 = x19 * x247 + x22 * x246
x249 = x248 * x3
x250 = x230 * x5
x251 = x250 * x96
x252 = x234 * x50
x253 = x74 * (x241 - x252)
x254 = x230 * x99
x255 = x236 + x254
x256 = x5 * x50
x257 = x74 * (-x231 * x256 + x232 * x5)
x258 = x236 * x3
x259 = x255 * x3 + x257 + x258
x260 = x232 * x44
x261 = x231 * x99 + x260
x262 = x239 * x44
x263 = x243 * x3 + x262
x264 = x3**2
x265 = x74 * (-x232 * x50 + x239)
x266 = x103 + x104 * x227
x267 = x102 + x106 * x227 - x266 * x7
x268 = -x239 * x7 + x266
x269 = x19 * x268 + x22 * x232
x270 = x74 * (x19 * x267 + x22 * x239 - x269 * x50)
x271 = x74 * (-x241 * x50 + x269)
x272 = 0.03253000243161777 * x111
x273 = x175 * x6 * (2.0 * x11 * x114 * x17 * x18 * x4 * x6 - x116)
x274 = x118 * x175 + 0.5 * x273
x275 = x149 * x175
x276 = x274 * x3 + x275
x277 = -2.0 * x11 * x114 * x17 * x175 * x30 * x4 * x6
x278 = -x6 * (x122 * x175 + x277)
x279 = x124 * x175 + 0.5 * x278
x280 = x160 * x175
x281 = x279 * x3 + x280
x282 = x175 * x6 * (2.0 * x11 * x114 * x17 * x4 * x6 * x9 - x138)
x283 = x140 * x175 + 0.5 * x282
x284 = x175 * x21
x285 = x115 * x284
x286 = x285 * x86
x287 = x74 * (-x274 * x50 + x279)
x288 = x114 * x175
x289 = x288 * x9
x290 = x289 * x97
x291 = x155 * x24 * x284 + x290
x292 = x74 * (2.0 * x11 * x114 * x17 * x175 * x18 * x4 * x5 * x6 - x148 * x220)
x293 = x290 * x3 + x291 * x3 + x292
x294 = x154 * x175 + x155 * x212
x295 = x175 * x38
x296 = x155 * x295 + x288 * x98
x297 = -x74 * (x153 * x220 + x277)
x298 = x114 * x175 * x32
x299 = x175 * x6 * (2.0 * x11 * x114 * x17 * x4 * x52 * x6 - x167)
x300 = x175 * x6 * (2.0 * x11 * x114 * x17 * x36 * x4 * x6 - x132)
x301 = x134 * x175 + 0.5 * x300
x302 = 0.5 * x74 * (2.0 * x169 * x175 + x299 - 2.0 * x301 * x50)
x303 = x74 * (-x279 * x50 + x301)
x304 = 5.916079783099616 * x112
x305 = x175**2
x306 = x24 * x305
x307 = x20 + x21 * x306
x308 = x305 * x32 + x31
x309 = x305 * x38 + x37
x310 = -x308 * x7 + x309
x311 = x19 * x310
x312 = x22 * x307 + x311
x313 = x3 * x312
x314 = x308 * x44
x315 = x314 * x5
x316 = x313 + 2.0 * x315
x317 = x305 * x54 + x53
x318 = -x309 * x7 + x317
x319 = x19 * x318
x320 = x22 * x308 + x319
x321 = x3 * x320
x322 = x309 * x5
x323 = x321 + x322 * x96
x324 = x306 * x67 + x66
x325 = -x307 * x7 + x308
x326 = x19 * x325
x327 = x22 * x324 + x326
x328 = x3 * x327
x329 = x307 * x5
x330 = x312 * x50
x331 = x74 * (x320 - x330)
x332 = x307 * x99
x333 = x314 + x332
x334 = x74 * (-x256 * x308 + x309 * x5)
x335 = x3 * x314
x336 = x3 * x333 + x334 + x335
x337 = x309 * x44
x338 = x308 * x99
x339 = x337 + x338
x340 = x317 * x44
x341 = x3 * x322 + x340
x342 = x74 * (-x309 * x50 + x317)
x343 = x103 + x104 * x305
x344 = x102 + x106 * x305 - x343 * x7
x345 = x19 * x344
x346 = -x317 * x7 + x343
x347 = x19 * x346
x348 = x22 * x309 + x347
x349 = x74 * (x22 * x317 + x345 - x348 * x50)
x350 = x74 * (-x320 * x50 + x348)
x351 = x114 * x232 + x133
x352 = x114 * x231 + x123
x353 = x352 * x50
x354 = x114 * x230 + x117
x355 = x264 * x354
x356 = x74 * (x351 - x353)
x357 = x355 + x356
x358 = x352 * x44
x359 = x354 * x99
x360 = x358 + x359
x361 = x351 * x44
x362 = x352 * x5
x363 = x3 * x362
x364 = x361 + x363
x365 = x354 * x44
x366 = x114 * x246 + x139
x367 = x366 * x99
x368 = x74 * (-x256 * x354 + x352 * x5)
x369 = x3 * x365
x370 = x114 * x239 + x168
x371 = x5 * x74 * (-x351 * x50 + x370)
x372 = x74 * (x351 * x5 - x362 * x50)
x373 = x191 + x227 * x295
x374 = x182 + x212 * x227
x375 = x374 * x50
x376 = x175 * x229 + x177
x377 = x74 * (x373 - x375)
x378 = x264 * x376 + x377
x379 = x374 * x44
x380 = x376 * x99 + x379
x381 = x373 * x44
x382 = x374 * x5
x383 = x3 * x382 + x381
x384 = x376 * x44
x385 = x175 * x245 + x196
x386 = x74 * (-x256 * x376 + x374 * x5)
x387 = x175 * x227 * x54 + x223
x388 = x5 * x74 * (-x373 * x50 + x387)
x389 = x74 * (x373 * x5 - x382 * x50)
x390 = x114 * x50
x391 = x308 * x390
x392 = x74 * (x114 * x309 - x391)
x393 = x114 * x307
x394 = x264 * x393 + x392
x395 = x114 * x314
x396 = x114 * x332 + x395
x397 = x114 * x337
x398 = x114 * x338 + x397
x399 = x393 * x44
x400 = x74 * (x114 * x308 * x5 - x256 * x393)
x401 = x114 * x74 * (x317 * x5 - x322 * x50)
x402 = x115 * x308
x403 = x74 * (x114 * x309 * x5 - x402 * x50)
x404 = x175 * x309 + x190
x405 = x175 * x308 + x181
x406 = x405 * x50
x407 = x175 * x307 + x176
x408 = x264 * x407
x409 = x74 * (x404 - x406)
x410 = x408 + x409
x411 = x405 * x44
x412 = x407 * x99
x413 = x411 + x412
x414 = x404 * x44
x415 = x405 * x5
x416 = x3 * x415
x417 = x414 + x416
x418 = x407 * x44
x419 = x175 * x324 + x195
x420 = x419 * x99
x421 = x74 * (-x256 * x407 + x405 * x5)
x422 = x3 * x418
x423 = x175 * x317 + x222
x424 = x5 * x74 * (-x404 * x50 + x423)
x425 = x74 * (x404 * x5 - x415 * x50)
x426 = x114 * x352 + x240 * x41
x427 = x114 * x354 + x233 * x41
x428 = x427 * x50
x429 = x3 * x428
x430 = x114 * x366 + x247 * x41
x431 = x264 * x430
x432 = x74 * (x426 - x428)
x433 = x114 * x351 + x268 * x41
x434 = x74 * (x114 * x370 + x267 * x41 - x433 * x50)
x435 = x74 * (-x426 * x50 + x433)
x436 = x114 * x374 + x278
x437 = x114 * x376 + x273
x438 = x437 * x50
x439 = x114 * x385 + x282
x440 = x74 * (x436 - x438)
x441 = x114 * x373 + x300
x442 = x74 * (x114 * x387 + x299 - x441 * x50)
x443 = x74 * (-x436 * x50 + x441)
x444 = x227 * x308 + x319
x445 = x227 * x307 + x311
x446 = x445 * x50
x447 = x227 * x324 + x326
x448 = x74 * (x444 - x446)
x449 = x227 * x309 + x347
x450 = x74 * (x227 * x317 + x345 - x449 * x50)
x451 = x74 * (-x444 * x50 + x449)
x452 = x390 * x407
x453 = x74 * (x114 * x405 - x452)
x454 = x114 * x419
x455 = x114 * x74 * (-x404 * x50 + x423)
x456 = x114 * x405
x457 = x74 * (x114 * x404 - x456 * x50)
x458 = x175 * x405 + x318 * x41
x459 = x175 * x407 + x310 * x41
x460 = x459 * x50
x461 = x3 * x460
x462 = x175 * x419 + x325 * x41
x463 = x264 * x462
x464 = x74 * (x458 - x460)
x465 = x175 * x404 + x346 * x41
x466 = x74 * (x175 * x423 + x344 * x41 - x465 * x50)
x467 = x74 * (-x458 * x50 + x465)
x468 = -x113 - A[1]
x469 = x468 * x60
x470 = x468 * x70
x471 = x468 * x72
x472 = x468 * x73
x473 = x4 * (x468 * x57 - x472)
x474 = x468 * x76
x475 = x468 * x78
x476 = x474 + x475
x477 = x4 * x468 * (x60 - x81)
x478 = x468 * x5
x479 = x18 * x86
x480 = x130 * x468
x481 = x480 + x61
x482 = x135 * x468 + x93
x483 = x120 * x468
x484 = x47 + x483
x485 = x125 * x468 + x91
x486 = x141 * x468
x487 = x486 + x71
x488 = x119 * x468
x489 = x488 + x77
x490 = x4 * (x481 - x484 * x50)
x491 = x84 * x97
x492 = x115 * x32
x493 = x468 * x492
x494 = x491 + x493
x495 = x494 * x96
x496 = x3 * x489 + x495
x497 = x4 * (x482 - x485 * x50)
x498 = x114 * x468
x499 = x44 * (x38 * x498 + x98)
x500 = 0.06666666666666667 * x111
x501 = x192 * x468
x502 = x4 * x468 * (x188 - x201)
x503 = x175 * x478 * x9
x504 = x203 * x468 + x503 * x86
x505 = x4 * x468 * (x192 - x208)
x506 = x211 * x468
x507 = x241 * x468
x508 = 2.0 * x136 + x507
x509 = x163 + x243 * x468
x510 = x234 * x468
x511 = 2.0 * x126
x512 = x510 + x511
x513 = x231 * x468
x514 = x160 + x5 * x513
x515 = x248 * x468
x516 = 2.0 * x143
x517 = x515 + x516
x518 = x230 * x478
x519 = x149 + x518
x520 = x4 * (-x50 * x512 + x508)
x521 = x153 * x86
x522 = x513 + x521
x523 = x44 * x522
x524 = x3 * x519 + x523
x525 = x4 * (-x50 * x514 + x509)
x526 = 0.08606629658238704 * x111
x527 = x193 + x279 * x468
x528 = x115 * x295 * x468 + x204 * x98
x529 = x528 * x96
x530 = x184 + x274 * x468
x531 = x115 * x212
x532 = x175 * x491 + x468 * x531
x533 = x532 * x96
x534 = x199 + x283 * x468
x535 = x24 * x285
x536 = x205 * x97 + x468 * x535
x537 = x536 * x96
x538 = x4 * (-x50 * x530 + x527)
x539 = x211 + x212 * x498
x540 = x44 * x539
x541 = x3 * x536 + x540
x542 = x4 * (-x50 * x532 + x528)
x543 = 2.23606797749979 * x500
x544 = x314 * x478
x545 = x322 * x468
x546 = x307 * x478
x547 = x4 * x468 * (x320 - x330)
x548 = x314 * x468
x549 = x332 * x468 + x548
x550 = x478 * x50
x551 = x4 * (-x308 * x550 + x309 * x468 * x5)
x552 = 3.0 * x262 + x351 * x468
x553 = x44 * x552
x554 = x362 * x468
x555 = x243 * x89 + x554
x556 = 3.0 * x260 + x352 * x468
x557 = x44 * x556
x558 = x354 * x468
x559 = x5 * x558
x560 = 3.0 * x236
x561 = x5 * x560 + x559
x562 = x558 + x560
x563 = x4 * (-x50 * x556 + x552)
x564 = x44 * x562
x565 = x366 * x478
x566 = x250 * x89
x567 = x565 + x566
x568 = x4 * (-x50 * x561 + x555)
x569 = x162 * x288
x570 = x373 * x468 + x569
x571 = x44 * x570
x572 = x280 + x382 * x468
x573 = x175 * x521
x574 = x374 * x468 + x573
x575 = x44 * x574
x576 = x376 * x468
x577 = x275 + x5 * x576
x578 = x289 * x86
x579 = x576 + x578
x580 = x4 * (-x50 * x574 + x570)
x581 = x44 * x579
x582 = x286 + x385 * x478
x583 = x4 * (-x50 * x577 + x572)
x584 = x114 * x309
x585 = x340 + x468 * x584
x586 = x44 * x585
x587 = x322 * x44 + x402 * x468
x588 = x308 * x498 + x337
x589 = x44 * x588
x590 = x315 + x393 * x478
x591 = x314 + x393 * x468
x592 = x4 * (-x50 * x588 + x585)
x593 = x44 * x591
x594 = x115 * x324
x595 = x329 * x44 + x468 * x594
x596 = x4 * (-x50 * x590 + x587)
x597 = x414 * x468
x598 = x411 * x468
x599 = x4 * x468 * (x404 - x406)
x600 = x418 * x468
x601 = x4 * (x405 * x468 * x5 - x407 * x550)
x602 = x426 * x468
x603 = 4.0 * x361
x604 = x602 + x603
x605 = x427 * x468
x606 = 4.0 * x358
x607 = x605 + x606
x608 = x50 * x607
x609 = x430 * x468
x610 = 4.0 * x365
x611 = x609 + x610
x612 = x4 * (x604 - x608)
x613 = 3.0 * x381 + x436 * x468
x614 = 3.0 * x379 + x437 * x468
x615 = x50 * x614
x616 = 3.0 * x384 + x439 * x468
x617 = x4 * (x613 - x615)
x618 = 2.0 * x397 + x444 * x468
x619 = 2.0 * x395 + x445 * x468
x620 = x50 * x619
x621 = x393 * x96 + x447 * x468
x622 = x4 * (x618 - x620)
x623 = x414 + x456 * x468
x624 = x407 * x498 + x411
x625 = x50 * x624
x626 = x418 + x454 * x468
x627 = x4 * (x623 - x625)
x628 = x4 * x468 * (x458 - x460)
x629 = -x174 - A[2]
x630 = x4 * x629 * (x57 - x73)
x631 = 0.5 * x630
x632 = x629 * (x76 + x78)
x633 = x4 * x629 * (x60 - x81)
x634 = 0.5 * x633
x635 = x5 * x629
x636 = x135 * x629
x637 = x4 * x629 * (x130 - x145)
x638 = 0.5 * x637
x639 = x149 * x629
x640 = x147 * x629 + x639
x641 = x4 * x629 * (x135 - x151)
x642 = 0.5 * x641
x643 = x154 * x629
x644 = x188 * x629 + x61
x645 = x192 * x629 + x93
x646 = x44 * x645
x647 = x179 * x629 + x47
x648 = x183 * x629 + x91
x649 = x44 * x648
x650 = x197 * x629 + x71
x651 = x3 * x650
x652 = x178 * x629 + x77
x653 = x44 * x652
x654 = 3.0 * x653
x655 = x50 * x647
x656 = x4 * (x644 - x655)
x657 = 0.5 * x656
x658 = x3 * x652
x659 = x212 * x635 + x491
x660 = x44 * x659
x661 = 2.0 * x660
x662 = x658 + x661
x663 = x4 * (-x50 * x648 + x645)
x664 = 0.5 * x663
x665 = x295 * x629
x666 = x44 * (x665 + x98)
x667 = x236 * x629
x668 = x5 * x667
x669 = x243 * x629
x670 = x4 * x629 * (x241 - x252)
x671 = 0.5 * x670
x672 = x254 * x629 + x667
x673 = x50 * x635
x674 = x4 * (-x231 * x673 + x232 * x5 * x629)
x675 = 0.5 * x674
x676 = x136 + x279 * x629
x677 = x115 * (x665 + x98)
x678 = x677 * x96
x679 = x126 + x274 * x629
x680 = x159 * x97 + x531 * x629
x681 = x680 * x96
x682 = x143 + x283 * x629
x683 = x148 * x97
x684 = x535 * x629 + x683
x685 = x684 * x96
x686 = x4 * (-x50 * x679 + x676)
x687 = 0.5 * x686
x688 = x154 + x298 * x629
x689 = x44 * x688
x690 = x3 * x684 + x689
x691 = x4 * (-x50 * x680 + x677)
x692 = 0.5 * x691
x693 = 2.0 * x193 + x320 * x629
x694 = x218 + x322 * x629
x695 = x44 * x694
x696 = 2.0 * x184 + x312 * x629
x697 = x308 * x629
x698 = x216 + x5 * x697
x699 = x44 * x698
x700 = 2.0 * x199 + x327 * x629
x701 = x3 * x700
x702 = x206 + x329 * x629
x703 = x44 * x702
x704 = 2.0 * x703
x705 = x50 * x696
x706 = x4 * (x693 - x705)
x707 = 0.5 * x706
x708 = x210 * x86 + x697
x709 = x44 * x708
x710 = x3 * x702
x711 = x709 + x710
x712 = x4 * (-x50 * x698 + x694)
x713 = 0.5 * x712
x714 = x361 * x629
x715 = x358 * x629
x716 = x4 * x629 * (x351 - x353)
x717 = 0.5 * x716
x718 = x365 * x629
x719 = x4 * (x352 * x5 * x629 - x354 * x673)
x720 = 0.5 * x719
x721 = x262 + x373 * x629
x722 = x44 * x721
x723 = x243 * x44 + x382 * x629
x724 = x260 + x374 * x629
x725 = x44 * x724
x726 = x376 * x629
x727 = x237 + x5 * x726
x728 = x236 + x726
x729 = x4 * (-x50 * x724 + x721)
x730 = 0.5 * x729
x731 = x44 * x728
x732 = x250 * x44
x733 = x385 * x635 + x732
x734 = x4 * (-x50 * x727 + x723)
x735 = 0.5 * x734
x736 = x569 + x584 * x629
x737 = x44 * x736
x738 = x115 * x697 + x280
x739 = x114 * x697 + x573
x740 = x44 * x739
x741 = x275 + x393 * x635
x742 = x393 * x629 + x578
x743 = x4 * (-x50 * x739 + x736)
x744 = 0.5 * x743
x745 = x44 * x742
x746 = x286 + x594 * x629
x747 = x4 * (-x50 * x741 + x738)
x748 = 0.5 * x747
x749 = 3.0 * x340 + x404 * x629
x750 = x44 * x749
x751 = x322 * x89 + x415 * x629
x752 = 3.0 * x337 + x405 * x629
x753 = x44 * x752
x754 = x407 * x629
x755 = 3.0 * x315 + x5 * x754
x756 = 3.0 * x314 + x754
x757 = x4 * (-x50 * x752 + x749)
x758 = 0.5 * x757
x759 = x44 * x756
x760 = x329 * x89 + x419 * x635
x761 = x3 * x760
x762 = x50 * x755
x763 = x4 * (x751 - x762)
x764 = 0.5 * x763
x765 = x3 * x759
x766 = x4 * x629 * (x426 - x428)
x767 = 0.5 * x766
x768 = x361 + x436 * x629
x769 = x358 + x437 * x629
x770 = x50 * x769
x771 = x365 + x439 * x629
x772 = x4 * (x768 - x770)
x773 = 0.5 * x772
x774 = 2.0 * x381 + x444 * x629
x775 = 2.0 * x379 + x445 * x629
x776 = x50 * x775
x777 = 2.0 * x384 + x447 * x629
x778 = x4 * (x774 - x776)
x779 = 0.5 * x778
x780 = 3.0 * x397 + x456 * x629
x781 = x114 * x754 + 3.0 * x395
x782 = x50 * x781
x783 = x393 * x89 + x454 * x629
x784 = x4 * (x780 - x782)
x785 = 0.5 * x784
x786 = 4.0 * x414 + x458 * x629
x787 = 4.0 * x411 + x459 * x629
x788 = x50 * x787
x789 = 4.0 * x418 + x462 * x629
x790 = x264 * x789
x791 = x4 * (x786 - x788)
x792 = 0.5 * x791
x793 = x468**2
x794 = x69 * x793
x795 = x75 + x794
x796 = x28 * x793
x797 = x796 + x82
x798 = x44 * x797
x799 = x108 - x50 * (x109 + x42 * x793) + x57 * x793
x800 = x44 * (x34 * x793 + x95)
x801 = x468 * x71
x802 = x146 + x468 * x487 + x801
x803 = x468 * x77
x804 = x152 + x468 * x489 + x803
x805 = x171 + x44 * x469 + x468 * x481 - x50 * (x172 + x468 * x47 + x468 * x484)
x806 = x18 * x97
x807 = x96 * (x166 + x468 * x494 + x478 * x806)
x808 = x197 * x793 + x202
x809 = x178 * x793 + x209
x810 = x44 * x809
x811 = x188 * x793 + x225 - x50 * (x179 * x793 + x226)
x812 = x5 * x793
x813 = x44 * (x212 * x812 + x221)
x814 = x253 + x468 * x517 + x489 * x96
x815 = x257 + x468 * x519 + x495
x816 = x270 + x468 * x508 + x482 * x96 - x50 * (x271 + x468 * x512 + x485 * x96)
x817 = x44 * (x265 + x468 * x522 + 2.0 * x499)
x818 = 0.1111111111111111 * x111
x819 = x199 * x468 + x287 + x468 * x534
x820 = x292 + x468 * x536 + x503 * x97
x821 = x820 * x96
x822 = x302 + x44 * x501 + x468 * x527 - x50 * (x184 * x468 + x303 + x468 * x530)
x823 = x44 * (x297 + x468 * x539 + x506)
x824 = 1.732050807568877 * x818
x825 = x327 * x793 + x331
x826 = x329 * x793 + x334
x827 = x44 * x826
x828 = x320 * x793 + x349 - x50 * (x312 * x793 + x350)
x829 = x44 * (x308 * x793 + x342)
x830 = x356 + x468 * x562 + 3.0 * x523
x831 = x44 * x830
x832 = x368 + x468 * x567 + x519 * x89
x833 = x371 + x468 * x555 - x50 * (x372 + x468 * x561 + x514 * x89) + x509 * x89
x834 = x377 + x468 * x579 + 2.0 * x540
x835 = x44 * x834
x836 = x386 + x468 * x582 + x537
x837 = x388 + x468 * x572 - x50 * (x389 + x468 * x577 + x533) + x529
x838 = x392 + x468 * x591 + x548
x839 = x44 * x838
x840 = x400 + x44 * x546 + x468 * x595
x841 = x401 + x44 * x545 + x468 * x587 - x50 * (x403 + x468 * x590 + x544)
x842 = x407 * x793
x843 = x409 + x842
x844 = x44 * x843
x845 = x419 * x812 + x421
x846 = x415 * x793 + x424 - x50 * (x425 + x5 * x842)
x847 = x432 + x468 * x611 + 4.0 * x564
x848 = x434 + x468 * x604 - x50 * (x435 + x468 * x607 + 4.0 * x557) + 4.0 * x553
x849 = x440 + x468 * x616 + 3.0 * x581
x850 = x442 + x468 * x613 - x50 * (x443 + x468 * x614 + 3.0 * x575) + 3.0 * x571
x851 = x448 + x468 * x621 + 2.0 * x593
x852 = x450 + x468 * x618 - x50 * (x451 + x468 * x619 + 2.0 * x589) + 2.0 * x586
x853 = x453 + x468 * x626 + x600
x854 = x455 + x468 * x623 - x50 * (x457 + x468 * x624 + x598) + x597
x855 = x462 * x793 + x464
x856 = x458 * x793 + x466 - x50 * (x459 * x793 + x467)
x857 = x4 * x629 * (x468 * x57 - x472)
x858 = x629 * x71
x859 = x486 * x629 + x858
x860 = x629 * x77
x861 = x488 * x629 + x860
x862 = x61 * x629
x863 = x47 * x629
x864 = x4 * (x480 * x629 - x50 * (x483 * x629 + x863) + x862)
x865 = x635 * x806
x866 = x96 * (x493 * x629 + x865)
x867 = x4 * x468 * (x644 - x655)
x868 = x629 * (x515 + x516)
x869 = x518 * x629 + x639
x870 = x4 * (-x50 * x629 * (x510 + x511) + x507 * x629 + x636 * x96)
x871 = x44 * x629 * (x513 + x521)
x872 = x468 * x682 + x653
x873 = x468 * x684 + x660
x874 = x873 * x96
x875 = x4 * (x468 * x676 - x50 * (x468 * x679 + x649) + x646)
x876 = x44 * (x468 * x688 + x666)
x877 = 0.3333333333333333 * x111
x878 = x4 * x468 * (x693 - x705)
x879 = x468 * x709
x880 = x629 * (x558 + x560)
x881 = x44 * x880
x882 = x629 * (x565 + x566)
x883 = x4 * (-x50 * (x559 * x629 + x560 * x635) + x554 * x629 + x669 * x89)
x884 = 2.0 * x689
x885 = x468 * x728 + x884
x886 = x44 * x885
x887 = x468 * x733 + x685
x888 = x4 * (x468 * x723 - x50 * (x468 * x727 + x681) + x678)
x889 = x468 * x742 + x709
x890 = x44 * x889
x891 = x468 * x746 + x703
x892 = x4 * (x468 * x738 - x50 * (x468 * x741 + x699) + x695)
x893 = x468 * x759
x894 = x4 * x468 * (x751 - x762)
x895 = x629 * (x609 + x610)
x896 = x4 * x629 * (-x50 * (x605 + x606) + x602 + x603)
x897 = x468 * x771 + 3.0 * x731
x898 = x4 * (x468 * x768 - x50 * (x468 * x769 + 3.0 * x725) + 3.0 * x722)
x899 = x468 * x777 + 2.0 * x745
x900 = x4 * (x468 * x774 - x50 * (x468 * x775 + 2.0 * x740) + 2.0 * x737)
x901 = x468 * x783 + x759
x902 = x4 * (x468 * x780 - x50 * (x468 * x781 + x753) + x750)
x903 = x4 * x468 * (x786 - x788)
x904 = x629**2
x905 = x69 * x904 + x75
x906 = x3 * x905
x907 = x28 * x904 + x82
x908 = x44 * x907
x909 = 4.0 * x908
x910 = x108 - x50 * (x109 + x42 * x904) + x57 * x904
x911 = x74 * x910
x912 = x44 * (x34 * x904 + x95)
x913 = x141 * x904 + x146
x914 = x119 * x904 + x152
x915 = x44 * x914
x916 = x130 * x904 + x171 - x50 * (x120 * x904 + x172)
x917 = x74 * x916
x918 = x44 * (x166 + x492 * x904)
x919 = 2.0 * x918
x920 = x202 + x629 * x650 + x858
x921 = x3 * x920
x922 = x209 + x629 * x652 + x860
x923 = x44 * x922
x924 = 3.0 * x923
x925 = x225 - x50 * (x226 + x629 * x647 + x863) + x629 * x644 + x862
x926 = x74 * x925
x927 = x44 * (x221 + x629 * x659 + x865)
x928 = 2.0 * x927
x929 = x248 * x904 + x253
x930 = x250 * x904 + x257
x931 = x44 * x930
x932 = x241 * x904 + x270 - x50 * (x234 * x904 + x271)
x933 = x74 * x932
x934 = x44 * (x231 * x904 + x265)
x935 = x143 * x629 + x287 + x629 * x682
x936 = x292 + x629 * x683 + x629 * x684
x937 = x936 * x96
x938 = x302 + x44 * x636 - x50 * (x126 * x629 + x303 + x629 * x679) + x629 * x676
x939 = x74 * x938
x940 = x44 * (x297 + x629 * x688 + x643)
x941 = x331 + x629 * x700 + 2.0 * x653
x942 = x3 * x941
x943 = x334 + x629 * x702 + x661
x944 = x44 * x943
x945 = 2.0 * x944
x946 = x349 - x50 * (x350 + x629 * x696 + 2.0 * x649) + x629 * x693 + 2.0 * x646
x947 = x74 * x946
x948 = x44 * (x342 + x629 * x708 + 2.0 * x666)
x949 = x354 * x904
x950 = x356 + x949
x951 = x44 * x950
x952 = x366 * x5 * x904 + x368
x953 = x362 * x904 + x371 - x50 * (x372 + x5 * x949)
x954 = x74 * x953
x955 = x377 + x629 * x728 + x667
x956 = x44 * x955
x957 = x386 + x629 * x732 + x629 * x733
x958 = x388 + x44 * x669 - x50 * (x389 + x629 * x727 + x668) + x629 * x723
x959 = x74 * x958
x960 = x392 + x629 * x742 + x884
x961 = x44 * x960
x962 = x400 + x629 * x746 + x685
x963 = x401 - x50 * (x403 + x629 * x741 + x681) + x629 * x738 + x678
x964 = x74 * x963
x965 = x409 + x629 * x756 + 3.0 * x709
x966 = x44 * x965
x967 = x421 + x629 * x760 + 3.0 * x703
x968 = x3 * x967
x969 = x424 - x50 * (x425 + x629 * x755 + 3.0 * x699) + x629 * x751 + 3.0 * x695
x970 = x74 * x969
x971 = x430 * x904 + x432
x972 = x426 * x904 + x434 - x50 * (x427 * x904 + x435)
x973 = x74 * x972
x974 = x440 + x629 * x771 + x718
x975 = x442 - x50 * (x443 + x629 * x769 + x715) + x629 * x768 + x714
x976 = x74 * x975
x977 = x448 + x629 * x777 + 2.0 * x731
x978 = x450 - x50 * (x451 + x629 * x775 + 2.0 * x725) + x629 * x774 + 2.0 * x722
x979 = x74 * x978
x980 = x453 + x629 * x783 + 3.0 * x745
x981 = x455 - x50 * (x457 + x629 * x781 + 3.0 * x740) + x629 * x780 + 3.0 * x737
x982 = x74 * x981
x983 = x464 + x629 * x789 + 4.0 * x759
x984 = x466 - x50 * (x467 + x629 * x787 + 4.0 * x753) + x629 * x786 + 4.0 * x750
x985 = x74 * x984
x986 = x468 * x795 + x473
x987 = x44 * (x468 * x797 + x477)
x988 = x468 * x802 + x490 + x798
x989 = x468 * x804 + x497 + x800
x990 = x468 * x808 + x502
x991 = x44 * (x468 * x809 + x505)
x992 = x468 * x814 + x520 + x804 * x96
x993 = x468 * x815 + x525 + x807
x994 = x468 * x819 + x538 + x810
x995 = x96 * (x468 * x820 + x542 + x813)
x996 = x468 * x825 + x547
x997 = x44 * (x468 * x826 + x551)
x998 = x44 * (x468 * x830 + x563 + 3.0 * x817)
x999 = x468 * x832 + x568 + x815 * x89
x1000 = x44 * (x468 * x834 + x580 + 2.0 * x823)
x1001 = x468 * x836 + x583 + x821
x1002 = x44 * (x468 * x838 + x592 + x829)
x1003 = x468 * x840 + x596 + x827
x1004 = x44 * (x468 * x843 + x599)
x1005 = x468 * x845 + x601
x1006 = x468 * x847 + x612 + 4.0 * x831
x1007 = x173 * x3
x1008 = x468 * x849 + x617 + 3.0 * x835
x1009 = x3 * x500
x1010 = x468 * x851 + x622 + 2.0 * x839
x1011 = x3 * x526
x1012 = x468 * x853 + x627 + x844
x1013 = x468 * x855 + x628
x1014 = x629 * x794 + x631
x1015 = x44 * (x629 * x796 + x634)
x1016 = x468 * x859 + x629 * x801 + x638
x1017 = x468 * x861 + x629 * x803 + x642
x1018 = x650 * x793 + x657
x1019 = x44 * (x652 * x793 + x664)
x1020 = x468 * x868 + x671 + x861 * x96
x1021 = x468 * x869 + x675 + x866
x1022 = x468 * x653 + x468 * x872 + x687
x1023 = x96 * (x468 * x660 + x468 * x873 + x692)
x1024 = x700 * x793 + x707
x1025 = x44 * (x702 * x793 + x713)
x1026 = x44 * (x468 * x880 + x717 + 3.0 * x871)
x1027 = x468 * x882 + x720 + x869 * x89
x1028 = x44 * (x468 * x885 + x730 + 2.0 * x876)
x1029 = x468 * x887 + x735 + x874
x1030 = x44 * (x468 * x889 + x744 + x879)
x1031 = x468 * x703 + x468 * x891 + x748
x1032 = x44 * (x756 * x793 + x758)
x1033 = x760 * x793 + x764
x1034 = x468 * x895 + x767 + 4.0 * x881
x1035 = x3 * x304
x1036 = x468 * x897 + x773 + 3.0 * x886
x1037 = x3 * x543
x1038 = x468 * x899 + x779 + 2.0 * x890
x1039 = x3 * x824
x1040 = x468 * x901 + x785 + x893
x1041 = x789 * x793 + x792
x1042 = x468 * x913 + x908
x1043 = x468 * x914 + x912
x1044 = x468 * x929 + 2.0 * x915
x1045 = x468 * x930 + x919
x1046 = x468 * x935 + x923
x1047 = x96 * (x468 * x936 + x927)
x1048 = x44 * (x468 * x950 + 3.0 * x934)
x1049 = x468 * x952 + 3.0 * x931
x1050 = 2.0 * x940
x1051 = x44 * (x1050 + x468 * x955)
x1052 = x468 * x957 + x937
x1053 = x44 * (x468 * x960 + x948)
x1054 = x468 * x962 + x944
x1055 = x468 * x966
x1056 = x468 * x971 + 4.0 * x951
x1057 = x468 * x974 + 3.0 * x956
x1058 = x468 * x977 + 2.0 * x961
x1059 = x468 * x980 + x966
x1060 = x629 * x905 + x630
x1061 = x44 * (x629 * x907 + x633)
x1062 = x629 * x913 + x637
x1063 = x44 * (x629 * x914 + x641)
x1064 = x629 * x920 + x656 + x908
x1065 = x44 * (x629 * x922 + x663 + x912)
x1066 = x629 * x929 + x670
x1067 = x44 * (x629 * x930 + x674)
x1068 = x629 * x935 + x686 + x915
x1069 = x96 * (x629 * x936 + x691 + x918)
x1070 = x629 * x941 + x706 + 2.0 * x923
x1071 = x44 * (x629 * x943 + x712 + x928)
x1072 = x44 * (x629 * x950 + x716)
x1073 = x629 * x952 + x719
x1074 = x44 * (x629 * x955 + x729 + x934)
x1075 = x629 * x957 + x734 + x931
x1076 = x44 * (x1050 + x629 * x960 + x743)
x1077 = x629 * x962 + x747 + x937
x1078 = x44 * (x629 * x965 + x757 + 3.0 * x948)
x1079 = x629 * x967 + x763 + 3.0 * x944
x1080 = x629 * x971 + x766
x1081 = x629 * x974 + x772 + x951
x1082 = x629 * x977 + x778 + 2.0 * x956
x1083 = x629 * x980 + x784 + 3.0 * x961
x1084 = x629 * x983 + x791 + 4.0 * x966
x1085 = x173 * x468
x1086 = x468 * x500
# 225 item(s)
result[0, 0] = numpy.sum(
x112
* (
x110 * (x108 + x3 * x63 - x50 * (x109 + x3 * x49 + x80 * x92) + x80 * x94)
+ x3
* (
x3 * (x3 * (x70 + x72) + x75 + x79 * x80)
- x4 * (x49 * x50 - x63)
+ x80 * x90
)
+ x80
* (
x3 * x90
- x4 * (x50 * x92 - x94)
+ x89 * (x3 * x88 + x95 + x96 * (x38 * x99 + x98))
)
)
)
result[0, 1] = numpy.sum(
x173
* (
x110 * (x137 * x3 + x164 * x89 + x171 - x50 * (x128 * x3 + x161 * x89 + x172))
+ x3
* (
x158 * x89
+ x3 * (x146 + x150 * x89 + x3 * (x142 + x144))
- x4 * (x128 * x50 - x137)
)
+ x89
* (
x158 * x3
- x4 * (x161 * x50 - x164)
+ x96 * (x154 * x3 + x157 * x3 + x166)
)
)
)
result[0, 2] = numpy.sum(
x173
* (
x110 * (x194 * x3 + x219 * x89 + x225 - x50 * (x186 * x3 + x217 * x89 + x226))
+ x3
* (
x215 * x89
+ x3 * (x202 + x207 * x89 + x3 * (x198 + x200))
- x4 * (x186 * x50 - x194)
)
+ x89
* (
x215 * x3
- x4 * (x217 * x50 - x219)
+ x96 * (x211 * x3 + x214 * x3 + x221)
)
)
)
result[0, 3] = numpy.sum(
x272
* (
x110 * (x244 * x3 + x263 * x96 + x270 - x50 * (x238 * x3 + x261 * x96 + x271))
+ x3
* (
x259 * x96
+ x3 * (x253 + x255 * x96 + x3 * (x249 + x251))
- x4 * (x238 * x50 - x244)
)
+ x96 * (x259 * x3 - x4 * (x261 * x50 - x263) + x44 * (x231 * x264 + x265))
)
)
result[0, 4] = numpy.sum(
x304
* (
x110 * (x281 * x3 + x296 * x96 + x302 - x50 * (x276 * x3 + x294 * x96 + x303))
+ x3
* (
x293 * x96
+ x3 * (x287 + x291 * x96 + x3 * (x283 * x3 + x286))
- x4 * (x276 * x50 - x281)
)
+ x96 * (x293 * x3 - x4 * (x294 * x50 - x296) + x44 * (x264 * x298 + x297))
)
)
result[0, 5] = numpy.sum(
x272
* (
x110 * (x3 * x323 + x341 * x96 + x349 - x50 * (x3 * x316 + x339 * x96 + x350))
+ x3
* (
x3 * (x3 * (x328 + x329 * x96) + x331 + x333 * x96)
+ x336 * x96
- x4 * (x316 * x50 - x323)
)
+ x96 * (x3 * x336 - x4 * (x339 * x50 - x341) + x44 * (x264 * x308 + x342))
)
)
result[0, 6] = numpy.sum(
x173
* (
x110
* (x3 * x351 * x44 + x3 * x364 + x371 - x50 * (x3 * x358 + x3 * x360 + x372))
+ x3 * x44 * (x357 + x4 * (x351 - x353))
+ x3
* (
x3 * (x3 * (x365 + x367) + x368 + x369)
+ x357 * x44
- x4 * (x360 * x50 - x364)
)
)
)
result[0, 7] = numpy.sum(
x304
* (
x110
* (x3 * x373 * x44 + x3 * x383 + x388 - x50 * (x3 * x379 + x3 * x380 + x389))
+ x3 * x44 * (x378 + x4 * (x373 - x375))
+ x3
* (
x3 * (x3 * x384 + x3 * (x384 + x385 * x99) + x386)
+ x378 * x44
- x4 * (x380 * x50 - x383)
)
)
)
result[0, 8] = numpy.sum(
x304
* (
x110 * (x3 * x397 + x3 * x398 + x401 - x50 * (x114 * x335 + x3 * x396 + x403))
+ x3 * x44 * (x394 + x4 * (x114 * x309 - x391))
+ x3
* (
x3 * (x3 * x399 + x3 * (x155 * x324 + x399) + x400)
+ x394 * x44
- x4 * (x396 * x50 - x398)
)
)
)
result[0, 9] = numpy.sum(
x173
* (
x110
* (x3 * x404 * x44 + x3 * x417 + x424 - x50 * (x3 * x411 + x3 * x413 + x425))
+ x3 * x44 * (x4 * (x404 - x406) + x410)
+ x3
* (
x3 * (x3 * (x418 + x420) + x421 + x422)
- x4 * (x413 * x50 - x417)
+ x410 * x44
)
)
)
result[0, 10] = numpy.sum(
x112
* (
x110 * (x264 * x426 + x434 - x50 * (x264 * x427 + x435))
+ x3 * (x3 * (x431 + x432) + x4 * (x3 * x426 - x429))
)
)
result[0, 11] = numpy.sum(
x173
* (
x110 * (x264 * x436 + x442 - x50 * (x264 * x437 + x443))
+ x3**2 * (x264 * x439 + x4 * (x436 - x438) + x440)
)
)
result[0, 12] = numpy.sum(
x272
* (
x110 * (x264 * x444 + x450 - x50 * (x264 * x445 + x451))
+ x3**2 * (x264 * x447 + x4 * (x444 - x446) + x448)
)
)
result[0, 13] = numpy.sum(
x173
* (
x110 * (x264 * x456 + x455 - x50 * (x114 * x408 + x457))
+ x3**2 * (x264 * x454 + x4 * (x114 * x405 - x452) + x453)
)
)
result[0, 14] = numpy.sum(
x112
* (
x110 * (x264 * x458 + x466 - x50 * (x264 * x459 + x467))
+ x3 * (x3 * (x463 + x464) + x4 * (x3 * x458 - x461))
)
)
result[1, 0] = numpy.sum(
0.5
* x173
* (
x3 * (2.0 * x3 * (x470 + x471) + x473 + 2.0 * x476 * x80)
+ 2.0 * x4 * (-x468 * x50 * (x43 + x48) + x468 * x58 + x469 * x80)
+ x80 * (2.0 * x3 * x476 + x477 + 2.0 * x89 * (x468 * x83 + x478 * x479))
)
)
result[1, 1] = numpy.sum(
0.5
* x500
* (
x3 * (2.0 * x3 * (x3 * x487 + x489 * x89) + x490 + 2.0 * x496 * x89)
+ 2.0 * x4 * (x3 * x481 + x482 * x89 - x50 * (x3 * x484 + x485 * x89))
+ x89 * (2.0 * x3 * x496 + x497 + 2.0 * x96 * (x3 * x494 + x499))
)
)
result[1, 2] = numpy.sum(
0.5
* x500
* (
x3 * (2.0 * x3 * x468 * (x198 + x200) + x502 + 2.0 * x504 * x89)
+ 2.0 * x4 * (x189 * x468 - x468 * x50 * (x180 + x185) + x501 * x89)
+ x89 * (2.0 * x3 * x504 + x505 + 2.0 * x96 * (x213 * x468 + x506))
)
)
result[1, 3] = numpy.sum(
0.5
* x526
* (
x3 * (2.0 * x3 * (x3 * x517 + x519 * x96) + x520 + 2.0 * x524 * x96)
+ 2.0 * x4 * (x3 * x508 - x50 * (x3 * x512 + x514 * x96) + x509 * x96)
+ x96 * (2.0 * x3 * x523 + 2.0 * x3 * x524 + x525)
)
)
result[1, 4] = numpy.sum(
0.5
* x543
* (
x3 * (2.0 * x3 * (x3 * x534 + x537) + x538 + 2.0 * x541 * x96)
+ 2.0 * x4 * (x3 * x527 - x50 * (x3 * x530 + x533) + x529)
+ x96 * (2.0 * x3 * x540 + 2.0 * x3 * x541 + x542)
)
)
result[1, 5] = numpy.sum(
0.5
* x526
* (
x3 * (2.0 * x3 * (x328 * x468 + x546 * x96) + x547 + 2.0 * x549 * x96)
+ 2.0 * x4 * (x321 * x468 - x50 * (x313 * x468 + 2.0 * x544) + x545 * x96)
+ x96 * (2.0 * x3 * x549 + 2.0 * x335 * x468 + x551)
)
)
result[1, 6] = numpy.sum(
0.5
* x500
* (
x3 * (2.0 * x3 * x564 + 2.0 * x3 * (x3 * x567 + x564) + x568)
+ 2.0 * x4 * (x3 * x555 - x50 * (x3 * x561 + x557) + x553)
+ x44 * (2.0 * x264 * x562 + x563)
)
)
result[1, 7] = numpy.sum(
0.5
* x543
* (
x3 * (2.0 * x3 * x581 + 2.0 * x3 * (x3 * x582 + x581) + x583)
+ 2.0 * x4 * (x3 * x572 - x50 * (x3 * x577 + x575) + x571)
+ x44 * (2.0 * x264 * x579 + x580)
)
)
result[1, 8] = numpy.sum(
0.5
* x543
* (
x3 * (2.0 * x3 * x593 + 2.0 * x3 * (x3 * x595 + x593) + x596)
+ 2.0 * x4 * (x3 * x587 - x50 * (x3 * x590 + x589) + x586)
+ x44 * (2.0 * x264 * x591 + x592)
)
)
result[1, 9] = numpy.sum(
0.5
* x500
* (
x3 * (2.0 * x3 * (x420 * x468 + x600) + 2.0 * x422 * x468 + x601)
+ 2.0 * x4 * (x416 * x468 - x50 * (x412 * x468 + x598) + x597)
+ x44 * (2.0 * x408 * x468 + x599)
)
)
result[1, 10] = numpy.sum(
0.5 * x173 * x3 * (2.0 * x264 * x611 + 2.0 * x4 * (x604 - x608) + x612)
)
result[1, 11] = numpy.sum(
0.5 * x3 * x500 * (2.0 * x264 * x616 + 2.0 * x4 * (x613 - x615) + x617)
)
result[1, 12] = numpy.sum(
0.5 * x3 * x526 * (2.0 * x264 * x621 + 2.0 * x4 * (x618 - x620) + x622)
)
result[1, 13] = numpy.sum(
0.5 * x3 * x500 * (2.0 * x264 * x626 + 2.0 * x4 * (x623 - x625) + x627)
)
result[1, 14] = numpy.sum(
0.5
* x173
* (x3 * (2.0 * x463 * x468 + x628) + 2.0 * x4 * x468 * (x3 * x458 - x461))
)
result[2, 0] = numpy.sum(
x173
* (
x3 * (x3 * x629 * (x70 + x72) + x631 + x632 * x80)
+ x4 * x629 * (-x50 * (x43 + x48) + x58 + x62)
+ x80 * (x3 * x632 + x634 + x89 * (x479 * x635 + x629 * x83))
)
)
result[2, 1] = numpy.sum(
x500
* (
x3 * (x3 * x629 * (x142 + x144) + x638 + x640 * x89)
+ x4 * (x131 * x629 - x50 * x629 * (x121 + x127) + x636 * x89)
+ x89 * (x3 * x640 + x642 + x96 * (x156 * x629 + x643))
)
)
result[2, 2] = numpy.sum(
x500
* (
x3 * (x3 * (x651 + x654) + x657 + x662 * x89)
+ x4 * (x3 * x644 - x50 * (x3 * x647 + 3.0 * x649) + 3.0 * x646)
+ x89 * (x3 * x662 + x664 + x96 * (x3 * x659 + x666))
)
)
result[2, 3] = numpy.sum(
x526
* (
x3 * (x3 * x629 * (x249 + x251) + x671 + x672 * x96)
+ x4 * (x242 * x629 - x50 * (x235 * x629 + 2.0 * x668) + x669 * x96)
+ x96 * (x258 * x629 + x3 * x672 + x675)
)
)
result[2, 4] = numpy.sum(
x543
* (
x3 * (x3 * (x3 * x682 + x685) + x687 + x690 * x96)
+ x4 * (x3 * x676 - x50 * (x3 * x679 + x681) + x678)
+ x96 * (x3 * x689 + x3 * x690 + x692)
)
)
result[2, 5] = numpy.sum(
x526
* (
x3 * (x3 * (x701 + x704) + x707 + x711 * x96)
+ x4 * (x3 * x693 - x50 * (x3 * x696 + 2.0 * x699) + 2.0 * x695)
+ x96 * (x3 * x709 + x3 * x711 + x713)
)
)
result[2, 6] = numpy.sum(
x500
* (
x3 * (x3 * (x367 * x629 + x718) + x369 * x629 + x720)
+ x4 * (x363 * x629 - x50 * (x359 * x629 + x715) + x714)
+ x44 * (x355 * x629 + x717)
)
)
result[2, 7] = numpy.sum(
x543
* (
x3 * (x3 * x731 + x3 * (x3 * x733 + x731) + x735)
+ x4 * (x3 * x723 - x50 * (x3 * x727 + x725) + x722)
+ x44 * (x264 * x728 + x730)
)
)
result[2, 8] = numpy.sum(
x543
* (
x3 * (x3 * x745 + x3 * (x3 * x746 + x745) + x748)
+ x4 * (x3 * x738 - x50 * (x3 * x741 + x740) + x737)
+ x44 * (x264 * x742 + x744)
)
)
result[2, 9] = numpy.sum(
x500
* (
x3 * (x3 * (x759 + x761) + x764 + x765)
+ x4 * (x3 * x751 - x50 * (x3 * x755 + x753) + x750)
+ x44 * (x264 * x756 + x758)
)
)
result[2, 10] = numpy.sum(
x173 * (x3 * (x431 * x629 + x767) + x4 * x629 * (x3 * x426 - x429))
)
result[2, 11] = numpy.sum(x3 * x500 * (x264 * x771 + x4 * (x768 - x770) + x773))
result[2, 12] = numpy.sum(x3 * x526 * (x264 * x777 + x4 * (x774 - x776) + x779))
result[2, 13] = numpy.sum(x3 * x500 * (x264 * x783 + x4 * (x780 - x782) + x785))
result[2, 14] = numpy.sum(x173 * x3 * (x4 * (x786 - x788) + x790 + x792))
result[3, 0] = numpy.sum(
x272
* (x3 * (x3 * x795 + 4.0 * x798) + x74 * x799 + x80 * (x3 * x797 + 3.0 * x800))
)
result[3, 1] = numpy.sum(
x526 * (x3 * (x3 * x802 + x804 * x89) + x74 * x805 + x89 * (x3 * x804 + x807))
)
result[3, 2] = numpy.sum(
x526
* (x3 * (x3 * x808 + 3.0 * x810) + x74 * x811 + x89 * (x3 * x809 + 2.0 * x813))
)
result[3, 3] = numpy.sum(
x818 * (x3 * (x3 * x814 + x815 * x96) + x74 * x816 + x96 * (x3 * x815 + x817))
)
result[3, 4] = numpy.sum(
x824 * (x3 * (x3 * x819 + x821) + x74 * x822 + x96 * (x3 * x820 + x823))
)
result[3, 5] = numpy.sum(
x818 * (x3 * (x3 * x825 + 2.0 * x827) + x74 * x828 + x96 * (x3 * x826 + x829))
)
result[3, 6] = numpy.sum(x526 * (x3 * x831 + x3 * (x3 * x832 + x831) + x74 * x833))
result[3, 7] = numpy.sum(x824 * (x3 * x835 + x3 * (x3 * x836 + x835) + x74 * x837))
result[3, 8] = numpy.sum(x824 * (x3 * x839 + x3 * (x3 * x840 + x839) + x74 * x841))
result[3, 9] = numpy.sum(x526 * (x3 * x844 + x3 * (x3 * x845 + x844) + x74 * x846))
result[3, 10] = numpy.sum(x272 * (x264 * x847 + x74 * x848))
result[3, 11] = numpy.sum(x526 * (x264 * x849 + x74 * x850))
result[3, 12] = numpy.sum(x818 * (x264 * x851 + x74 * x852))
result[3, 13] = numpy.sum(x526 * (x264 * x853 + x74 * x854))
result[3, 14] = numpy.sum(x272 * (x264 * x855 + x74 * x856))
result[4, 0] = numpy.sum(
0.5
* x304
* (2.0 * x3 * x629 * (x470 + x471) + 2.0 * x629 * x80 * (x474 + x475) + x857)
)
result[4, 1] = numpy.sum(
0.5
* x543
* (2.0 * x3 * (x3 * x859 + x861 * x89) + x864 + 2.0 * x89 * (x3 * x861 + x866))
)
result[4, 2] = numpy.sum(
0.5
* x543
* (2.0 * x3 * x468 * (x651 + x654) + 2.0 * x468 * x89 * (x658 + x661) + x867)
)
result[4, 3] = numpy.sum(
0.5
* x824
* (2.0 * x3 * (x3 * x868 + x869 * x96) + x870 + 2.0 * x96 * (x3 * x869 + x871))
)
result[4, 4] = numpy.sum(
0.5
* x877
* (2.0 * x3 * (x3 * x872 + x874) + x875 + 2.0 * x96 * (x3 * x873 + x876))
)
result[4, 5] = numpy.sum(
0.5
* x824
* (2.0 * x3 * x468 * (x701 + x704) + x878 + 2.0 * x96 * (x468 * x710 + x879))
)
result[4, 6] = numpy.sum(0.5 * x543 * (2.0 * x3**2 * x882 + 4.0 * x3 * x881 + x883))
result[4, 7] = numpy.sum(0.5 * x877 * (2.0 * x3**2 * x887 + 4.0 * x3 * x886 + x888))
result[4, 8] = numpy.sum(0.5 * x877 * (2.0 * x3**2 * x891 + 4.0 * x3 * x890 + x892))
result[4, 9] = numpy.sum(
0.5 * x543 * (2.0 * x3 * (x468 * x761 + x893) + 2.0 * x468 * x765 + x894)
)
result[4, 10] = numpy.sum(0.5 * x304 * (2.0 * x264 * x895 + x896))
result[4, 11] = numpy.sum(0.5 * x543 * (2.0 * x264 * x897 + x898))
result[4, 12] = numpy.sum(0.5 * x824 * (2.0 * x264 * x899 + x900))
result[4, 13] = numpy.sum(0.5 * x543 * (2.0 * x264 * x901 + x902))
result[4, 14] = numpy.sum(0.5 * x304 * (2.0 * x468 * x790 + x903))
result[5, 0] = numpy.sum(
x272 * (x3 * (x906 + x909) + x80 * (x3 * x907 + 3.0 * x912) + x911)
)
result[5, 1] = numpy.sum(
x526 * (x3 * (x3 * x913 + 3.0 * x915) + x89 * (x3 * x914 + x919) + x917)
)
result[5, 2] = numpy.sum(
x526 * (x3 * (x921 + x924) + x89 * (x3 * x922 + x928) + x926)
)
result[5, 3] = numpy.sum(
x818 * (x3 * (x3 * x929 + 2.0 * x931) + x933 + x96 * (x3 * x930 + x934))
)
result[5, 4] = numpy.sum(
x824 * (x3 * (x3 * x935 + x937) + x939 + x96 * (x3 * x936 + x940))
)
result[5, 5] = numpy.sum(
x818 * (x3 * (x942 + x945) + x947 + x96 * (x3 * x943 + x948))
)
result[5, 6] = numpy.sum(x526 * (x3 * x951 + x3 * (x3 * x952 + x951) + x954))
result[5, 7] = numpy.sum(x824 * (x3 * x956 + x3 * (x3 * x957 + x956) + x959))
result[5, 8] = numpy.sum(x824 * (x3 * x961 + x3 * (x3 * x962 + x961) + x964))
result[5, 9] = numpy.sum(x526 * (x3 * x966 + x3 * (x966 + x968) + x970))
result[5, 10] = numpy.sum(x272 * (x264 * x971 + x973))
result[5, 11] = numpy.sum(x526 * (x264 * x974 + x976))
result[5, 12] = numpy.sum(x818 * (x264 * x977 + x979))
result[5, 13] = numpy.sum(x526 * (x264 * x980 + x982))
result[5, 14] = numpy.sum(x272 * (x264 * x983 + x985))
result[6, 0] = numpy.sum(x173 * (x3 * x986 + 4.0 * x987))
result[6, 1] = numpy.sum(x500 * (x3 * x988 + x89 * x989))
result[6, 2] = numpy.sum(x500 * (x3 * x990 + 3.0 * x991))
result[6, 3] = numpy.sum(x526 * (x3 * x992 + x96 * x993))
result[6, 4] = numpy.sum(x543 * (x3 * x994 + x995))
result[6, 5] = numpy.sum(x526 * (x3 * x996 + 2.0 * x997))
result[6, 6] = numpy.sum(x500 * (x3 * x999 + x998))
result[6, 7] = numpy.sum(x543 * (x1000 + x1001 * x3))
result[6, 8] = numpy.sum(x543 * (x1002 + x1003 * x3))
result[6, 9] = numpy.sum(x500 * (x1004 + x1005 * x3))
result[6, 10] = numpy.sum(x1006 * x1007)
result[6, 11] = numpy.sum(x1008 * x1009)
result[6, 12] = numpy.sum(x1010 * x1011)
result[6, 13] = numpy.sum(x1009 * x1012)
result[6, 14] = numpy.sum(x1007 * x1013)
result[7, 0] = numpy.sum(x304 * (x1014 * x3 + 4.0 * x1015))
result[7, 1] = numpy.sum(x543 * (x1016 * x3 + x1017 * x89))
result[7, 2] = numpy.sum(x543 * (x1018 * x3 + 3.0 * x1019))
result[7, 3] = numpy.sum(x824 * (x1020 * x3 + x1021 * x96))
result[7, 4] = numpy.sum(x877 * (x1022 * x3 + x1023))
result[7, 5] = numpy.sum(x824 * (x1024 * x3 + 2.0 * x1025))
result[7, 6] = numpy.sum(x543 * (x1026 + x1027 * x3))
result[7, 7] = numpy.sum(x877 * (x1028 + x1029 * x3))
result[7, 8] = numpy.sum(x877 * (x1030 + x1031 * x3))
result[7, 9] = numpy.sum(x543 * (x1032 + x1033 * x3))
result[7, 10] = numpy.sum(x1034 * x1035)
result[7, 11] = numpy.sum(x1036 * x1037)
result[7, 12] = numpy.sum(x1038 * x1039)
result[7, 13] = numpy.sum(x1037 * x1040)
result[7, 14] = numpy.sum(x1035 * x1041)
result[8, 0] = numpy.sum(x304 * x468 * (x906 + x909))
result[8, 1] = numpy.sum(x543 * (x1042 * x3 + x1043 * x89))
result[8, 2] = numpy.sum(x468 * x543 * (x921 + x924))
result[8, 3] = numpy.sum(x824 * (x1044 * x3 + x1045 * x96))
result[8, 4] = numpy.sum(x877 * (x1046 * x3 + x1047))
result[8, 5] = numpy.sum(x468 * x824 * (x942 + x945))
result[8, 6] = numpy.sum(x543 * (x1048 + x1049 * x3))
result[8, 7] = numpy.sum(x877 * (x1051 + x1052 * x3))
result[8, 8] = numpy.sum(x877 * (x1053 + x1054 * x3))
result[8, 9] = numpy.sum(x543 * (x1055 + x468 * x968))
result[8, 10] = numpy.sum(x1035 * x1056)
result[8, 11] = numpy.sum(x1037 * x1057)
result[8, 12] = numpy.sum(x1039 * x1058)
result[8, 13] = numpy.sum(x1037 * x1059)
result[8, 14] = numpy.sum(x1035 * x468 * x983)
result[9, 0] = numpy.sum(x173 * (x1060 * x3 + 4.0 * x1061))
result[9, 1] = numpy.sum(x500 * (x1062 * x3 + 3.0 * x1063))
result[9, 2] = numpy.sum(x500 * (x1064 * x3 + 3.0 * x1065))
result[9, 3] = numpy.sum(x526 * (x1066 * x3 + 2.0 * x1067))
result[9, 4] = numpy.sum(x543 * (x1068 * x3 + x1069))
result[9, 5] = numpy.sum(x526 * (x1070 * x3 + 2.0 * x1071))
result[9, 6] = numpy.sum(x500 * (x1072 + x1073 * x3))
result[9, 7] = numpy.sum(x543 * (x1074 + x1075 * x3))
result[9, 8] = numpy.sum(x543 * (x1076 + x1077 * x3))
result[9, 9] = numpy.sum(x500 * (x1078 + x1079 * x3))
result[9, 10] = numpy.sum(x1007 * x1080)
result[9, 11] = numpy.sum(x1009 * x1081)
result[9, 12] = numpy.sum(x1011 * x1082)
result[9, 13] = numpy.sum(x1009 * x1083)
result[9, 14] = numpy.sum(x1007 * x1084)
result[10, 0] = numpy.sum(x112 * (x110 * x799 + x468 * x986))
result[10, 1] = numpy.sum(x173 * (x110 * x805 + x468 * x988 + x987))
result[10, 2] = numpy.sum(x173 * (x110 * x811 + x468 * x990))
result[10, 3] = numpy.sum(x272 * (x110 * x816 + x468 * x992 + x96 * x989))
result[10, 4] = numpy.sum(x304 * (x110 * x822 + x468 * x994 + x991))
result[10, 5] = numpy.sum(x272 * (x110 * x828 + x468 * x996))
result[10, 6] = numpy.sum(x173 * (x110 * x833 + x468 * x999 + x89 * x993))
result[10, 7] = numpy.sum(x304 * (x1001 * x468 + x110 * x837 + x995))
result[10, 8] = numpy.sum(x304 * (x1003 * x468 + x110 * x841 + x997))
result[10, 9] = numpy.sum(x173 * (x1005 * x468 + x110 * x846))
result[10, 10] = numpy.sum(x112 * (x1006 * x468 + x110 * x848 + 4.0 * x998))
result[10, 11] = numpy.sum(x173 * (3.0 * x1000 + x1008 * x468 + x110 * x850))
result[10, 12] = numpy.sum(x272 * (2.0 * x1002 + x1010 * x468 + x110 * x852))
result[10, 13] = numpy.sum(x173 * (x1004 + x1012 * x468 + x110 * x854))
result[10, 14] = numpy.sum(x112 * (x1013 * x468 + x110 * x856))
result[11, 0] = numpy.sum(x173 * (x1014 * x468 + x857))
result[11, 1] = numpy.sum(x500 * (x1015 + x1016 * x468 + x864))
result[11, 2] = numpy.sum(x500 * (x1018 * x468 + x867))
result[11, 3] = numpy.sum(x526 * (x1017 * x96 + x1020 * x468 + x870))
result[11, 4] = numpy.sum(x543 * (x1019 + x1022 * x468 + x875))
result[11, 5] = numpy.sum(x526 * (x1024 * x468 + x878))
result[11, 6] = numpy.sum(x500 * (x1021 * x89 + x1027 * x468 + x883))
result[11, 7] = numpy.sum(x543 * (x1023 + x1029 * x468 + x888))
result[11, 8] = numpy.sum(x543 * (x1025 + x1031 * x468 + x892))
result[11, 9] = numpy.sum(x500 * (x1033 * x468 + x894))
result[11, 10] = numpy.sum(x173 * (4.0 * x1026 + x1034 * x468 + x896))
result[11, 11] = numpy.sum(x500 * (3.0 * x1028 + x1036 * x468 + x898))
result[11, 12] = numpy.sum(x526 * (2.0 * x1030 + x1038 * x468 + x900))
result[11, 13] = numpy.sum(x500 * (x1032 + x1040 * x468 + x902))
result[11, 14] = numpy.sum(x173 * (x1041 * x468 + x903))
result[12, 0] = numpy.sum(x272 * (x793 * x905 + x911))
result[12, 1] = numpy.sum(x526 * (x1042 * x468 + x468 * x908 + x917))
result[12, 2] = numpy.sum(x526 * (x793 * x920 + x926))
result[12, 3] = numpy.sum(x818 * (x1043 * x96 + x1044 * x468 + x933))
result[12, 4] = numpy.sum(x824 * (x1046 * x468 + x468 * x923 + x939))
result[12, 5] = numpy.sum(x818 * (x793 * x941 + x947))
result[12, 6] = numpy.sum(x526 * (x1045 * x89 + x1049 * x468 + x954))
result[12, 7] = numpy.sum(x824 * (x1047 + x1052 * x468 + x959))
result[12, 8] = numpy.sum(x824 * (x1054 * x468 + x468 * x944 + x964))
result[12, 9] = numpy.sum(x526 * (x793 * x967 + x970))
result[12, 10] = numpy.sum(x272 * (4.0 * x1048 + x1056 * x468 + x973))
result[12, 11] = numpy.sum(x526 * (3.0 * x1051 + x1057 * x468 + x976))
result[12, 12] = numpy.sum(x818 * (2.0 * x1053 + x1058 * x468 + x979))
result[12, 13] = numpy.sum(x526 * (x1055 + x1059 * x468 + x982))
result[12, 14] = numpy.sum(x272 * (x793 * x983 + x985))
result[13, 0] = numpy.sum(x1060 * x1085)
result[13, 1] = numpy.sum(x500 * (x1061 + x1062 * x468))
result[13, 2] = numpy.sum(x1064 * x1086)
result[13, 3] = numpy.sum(x526 * (2.0 * x1063 + x1066 * x468))
result[13, 4] = numpy.sum(x543 * (x1065 + x1068 * x468))
result[13, 5] = numpy.sum(x1070 * x468 * x526)
result[13, 6] = numpy.sum(x500 * (3.0 * x1067 + x1073 * x468))
result[13, 7] = numpy.sum(x543 * (x1069 + x1075 * x468))
result[13, 8] = numpy.sum(x543 * (x1071 + x1077 * x468))
result[13, 9] = numpy.sum(x1079 * x1086)
result[13, 10] = numpy.sum(x173 * (4.0 * x1072 + x1080 * x468))
result[13, 11] = numpy.sum(x500 * (3.0 * x1074 + x1081 * x468))
result[13, 12] = numpy.sum(x526 * (2.0 * x1076 + x1082 * x468))
result[13, 13] = numpy.sum(x500 * (x1078 + x1083 * x468))
result[13, 14] = numpy.sum(x1084 * x1085)
result[14, 0] = numpy.sum(x112 * (x1060 * x629 + x110 * x910))
result[14, 1] = numpy.sum(x173 * (x1062 * x629 + x110 * x916))
result[14, 2] = numpy.sum(x173 * (x1061 + x1064 * x629 + x110 * x925))
result[14, 3] = numpy.sum(x272 * (x1066 * x629 + x110 * x932))
result[14, 4] = numpy.sum(x304 * (x1063 + x1068 * x629 + x110 * x938))
result[14, 5] = numpy.sum(x272 * (2.0 * x1065 + x1070 * x629 + x110 * x946))
result[14, 6] = numpy.sum(x173 * (x1073 * x629 + x110 * x953))
result[14, 7] = numpy.sum(x304 * (x1067 + x1075 * x629 + x110 * x958))
result[14, 8] = numpy.sum(x304 * (x1069 + x1077 * x629 + x110 * x963))
result[14, 9] = numpy.sum(x173 * (3.0 * x1071 + x1079 * x629 + x110 * x969))
result[14, 10] = numpy.sum(x112 * (x1080 * x629 + x110 * x972))
result[14, 11] = numpy.sum(x173 * (x1072 + x1081 * x629 + x110 * x975))
result[14, 12] = numpy.sum(x272 * (2.0 * x1074 + x1082 * x629 + x110 * x978))
result[14, 13] = numpy.sum(x173 * (3.0 * x1076 + x1083 * x629 + x110 * x981))
result[14, 14] = numpy.sum(x112 * (4.0 * x1078 + x1084 * x629 + x110 * x984))
return result
int2c2e3d = {
(0, 0): int2c2e3d_00,
(0, 1): int2c2e3d_01,
(0, 2): int2c2e3d_02,
(0, 3): int2c2e3d_03,
(0, 4): int2c2e3d_04,
(1, 0): int2c2e3d_10,
(1, 1): int2c2e3d_11,
(1, 2): int2c2e3d_12,
(1, 3): int2c2e3d_13,
(1, 4): int2c2e3d_14,
(2, 0): int2c2e3d_20,
(2, 1): int2c2e3d_21,
(2, 2): int2c2e3d_22,
(2, 3): int2c2e3d_23,
(2, 4): int2c2e3d_24,
(3, 0): int2c2e3d_30,
(3, 1): int2c2e3d_31,
(3, 2): int2c2e3d_32,
(3, 3): int2c2e3d_33,
(3, 4): int2c2e3d_34,
(4, 0): int2c2e3d_40,
(4, 1): int2c2e3d_41,
(4, 2): int2c2e3d_42,
(4, 3): int2c2e3d_43,
(4, 4): int2c2e3d_44,
}