mlmm-toolkit 0.2.2.dev0__py3-none-any.whl

pysisyphus/wavefunction/ints/ovlp3d.py

@@ -0,0 +1,3777 @@
+"""
+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 = 4
+	lauxmax = 6
+	write = False
+	out_dir = devel_ints
+	keys = ['~2c2e', '~3c2e_sph']
+	sph = False
+	opt_basic = True
+	normalize = cgto
+"""
+
+import numpy
+
+
+def ovlp3d_00(ax, da, A, bx, db, B):
+    """Cartesian 3D (ss) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((1, 1), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = ax * bx * x0
+
+    # 1 item(s)
+    result[0, 0] = numpy.sum(
+        5.568327996831708
+        * da
+        * db
+        * x0**1.5
+        * numpy.exp(-x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+    return result
+
+
+def ovlp3d_01(ax, da, A, bx, db, B):
+    """Cartesian 3D (sp) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((1, 3), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = ax * bx * x0
+    x2 = (
+        5.568327996831708
+        * da
+        * db
+        * x0**1.5
+        * numpy.exp(-x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+
+    # 3 item(s)
+    result[0, 0] = numpy.sum(x2 * (x0 * (ax * A[0] + bx * B[0]) - B[0]))
+    result[0, 1] = numpy.sum(x2 * (x0 * (ax * A[1] + bx * B[1]) - B[1]))
+    result[0, 2] = numpy.sum(x2 * (x0 * (ax * A[2] + bx * B[2]) - B[2]))
+    return result
+
+
+def ovlp3d_02(ax, da, A, bx, db, B):
+    """Cartesian 3D (sd) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((1, 6), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = -x0 * (ax * A[0] + bx * B[0]) + B[0]
+    x2 = 0.5 * x0
+    x3 = ax * bx * x0
+    x4 = (
+        5.568327996831708
+        * da
+        * db
+        * x0**1.5
+        * numpy.exp(-x3 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+    x5 = 0.5773502691896258 * x4
+    x6 = -x0 * (ax * A[1] + bx * B[1]) + B[1]
+    x7 = x1 * x4
+    x8 = -x0 * (ax * A[2] + bx * B[2]) + B[2]
+
+    # 6 item(s)
+    result[0, 0] = numpy.sum(x5 * (x1**2 + x2))
+    result[0, 1] = numpy.sum(x6 * x7)
+    result[0, 2] = numpy.sum(x7 * x8)
+    result[0, 3] = numpy.sum(x5 * (x2 + x6**2))
+    result[0, 4] = numpy.sum(x4 * x6 * x8)
+    result[0, 5] = numpy.sum(x5 * (x2 + x8**2))
+    return result
+
+
+def ovlp3d_03(ax, da, A, bx, db, B):
+    """Cartesian 3D (sf) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((1, 10), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = -x0 * (ax * A[0] + bx * B[0]) + B[0]
+    x2 = x1**2
+    x3 = 1.5 * x0
+    x4 = 5.568327996831708
+    x5 = numpy.sqrt(x0)
+    x6 = ax * bx * x0
+    x7 = numpy.exp(-x6 * (A[0] - B[0]) ** 2)
+    x8 = numpy.exp(-x6 * (A[1] - B[1]) ** 2)
+    x9 = numpy.exp(-x6 * (A[2] - B[2]) ** 2)
+    x10 = da * db * x0 * x1 * x4 * x5 * x7 * x8 * x9
+    x11 = 0.2581988897471611
+    x12 = -x0 * (ax * A[1] + bx * B[1]) + B[1]
+    x13 = da * db * x0 * x4 * x5 * x7 * x8 * x9
+    x14 = x12 * x13
+    x15 = 0.5 * x0
+    x16 = 0.5773502691896258
+    x17 = x16 * (x15 + x2)
+    x18 = -x0 * (ax * A[2] + bx * B[2]) + B[2]
+    x19 = x13 * x18
+    x20 = x12**2
+    x21 = x15 + x20
+    x22 = x10 * x16
+    x23 = x18**2
+    x24 = x15 + x23
+
+    # 10 item(s)
+    result[0, 0] = numpy.sum(-x10 * x11 * (x2 + x3))
+    result[0, 1] = numpy.sum(-x14 * x17)
+    result[0, 2] = numpy.sum(-x17 * x19)
+    result[0, 3] = numpy.sum(-x21 * x22)
+    result[0, 4] = numpy.sum(-x10 * x12 * x18)
+    result[0, 5] = numpy.sum(-x22 * x24)
+    result[0, 6] = numpy.sum(-x11 * x14 * (x20 + x3))
+    result[0, 7] = numpy.sum(-x16 * x19 * x21)
+    result[0, 8] = numpy.sum(-x14 * x16 * x24)
+    result[0, 9] = numpy.sum(-x11 * x19 * (x23 + x3))
+    return result
+
+
+def ovlp3d_04(ax, da, A, bx, db, B):
+    """Cartesian 3D (sg) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((1, 15), dtype=float)
+
+    x0 = 0.5 / (ax + bx)
+    x1 = (ax + bx) ** (-1.0)
+    x2 = x1 * (ax * A[0] + bx * B[0]) - B[0]
+    x3 = ax * bx * x1
+    x4 = numpy.exp(-x3 * (A[0] - B[0]) ** 2)
+    x5 = 1.772453850905516 * numpy.sqrt(x1)
+    x6 = x4 * x5
+    x7 = x2**2 * x6
+    x8 = x0 * x6
+    x9 = x7 + x8
+    x10 = x2 * (2.0 * x8 + x9)
+    x11 = numpy.exp(-x3 * (A[1] - B[1]) ** 2)
+    x12 = da * db
+    x13 = numpy.exp(-x3 * (A[2] - B[2]) ** 2)
+    x14 = 3.141592653589793 * x1 * x13
+    x15 = x12 * x14
+    x16 = x11 * x15
+    x17 = 0.09759000729485332
+    x18 = x1 * (ax * A[1] + bx * B[1]) - B[1]
+    x19 = 0.2581988897471611
+    x20 = x18 * x19
+    x21 = x10 * x16
+    x22 = x1 * (ax * A[2] + bx * B[2]) - B[2]
+    x23 = x19 * x22
+    x24 = x11 * x5
+    x25 = x18**2 * x24
+    x26 = x0 * x24
+    x27 = x25 + x26
+    x28 = x13 * x5
+    x29 = 0.3333333333333333 * x12
+    x30 = x29 * x9
+    x31 = 1.732050807568877
+    x32 = x18 * x31
+    x33 = x14 * x22
+    x34 = x22**2 * x28
+    x35 = x0 * x28
+    x36 = x34 + x35
+    x37 = x2 * x4
+    x38 = x19 * x37
+    x39 = x18 * (2.0 * x26 + x27)
+    x40 = x15 * x39
+    x41 = x27 * x29
+    x42 = 3.141592653589793 * x1 * x11
+    x43 = x22 * (2.0 * x35 + x36)
+    x44 = x12 * x42
+    x45 = x43 * x44
+    x46 = x17 * x4
+
+    # 15 item(s)
+    result[0, 0] = numpy.sum(x16 * x17 * (3.0 * x0 * (x7 + x8) + x10 * x2))
+    result[0, 1] = numpy.sum(x20 * x21)
+    result[0, 2] = numpy.sum(x21 * x23)
+    result[0, 3] = numpy.sum(x27 * x28 * x30)
+    result[0, 4] = numpy.sum(x11 * x30 * x32 * x33)
+    result[0, 5] = numpy.sum(x24 * x30 * x36)
+    result[0, 6] = numpy.sum(x38 * x40)
+    result[0, 7] = numpy.sum(x31 * x33 * x37 * x41)
+    result[0, 8] = numpy.sum(x29 * x32 * x36 * x37 * x42)
+    result[0, 9] = numpy.sum(x38 * x45)
+    result[0, 10] = numpy.sum(x15 * x46 * (3.0 * x0 * (x25 + x26) + x18 * x39))
+    result[0, 11] = numpy.sum(x23 * x4 * x40)
+    result[0, 12] = numpy.sum(x36 * x41 * x6)
+    result[0, 13] = numpy.sum(x20 * x4 * x45)
+    result[0, 14] = numpy.sum(x44 * x46 * (3.0 * x0 * (x34 + x35) + x22 * x43))
+    return result
+
+
+def ovlp3d_10(ax, da, A, bx, db, B):
+    """Cartesian 3D (ps) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((3, 1), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = ax * bx * x0
+    x2 = (
+        5.568327996831708
+        * da
+        * db
+        * x0**1.5
+        * numpy.exp(-x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+
+    # 3 item(s)
+    result[0, 0] = numpy.sum(x2 * (x0 * (ax * A[0] + bx * B[0]) - A[0]))
+    result[1, 0] = numpy.sum(x2 * (x0 * (ax * A[1] + bx * B[1]) - A[1]))
+    result[2, 0] = numpy.sum(x2 * (x0 * (ax * A[2] + bx * B[2]) - A[2]))
+    return result
+
+
+def ovlp3d_11(ax, da, A, bx, db, B):
+    """Cartesian 3D (pp) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((3, 3), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = 0.5 * x0
+    x2 = -x0 * (ax * A[0] + bx * B[0])
+    x3 = x2 + A[0]
+    x4 = x2 + B[0]
+    x5 = ax * bx * x0
+    x6 = (
+        5.568327996831708
+        * da
+        * db
+        * x0**1.5
+        * numpy.exp(-x5 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+    x7 = -x0 * (ax * A[1] + bx * B[1])
+    x8 = x7 + B[1]
+    x9 = x3 * x6
+    x10 = -x0 * (ax * A[2] + bx * B[2])
+    x11 = x10 + B[2]
+    x12 = x7 + A[1]
+    x13 = x12 * x6
+    x14 = x10 + A[2]
+    x15 = x14 * x6
+
+    # 9 item(s)
+    result[0, 0] = numpy.sum(x6 * (x1 + x3 * x4))
+    result[0, 1] = numpy.sum(x8 * x9)
+    result[0, 2] = numpy.sum(x11 * x9)
+    result[1, 0] = numpy.sum(x13 * x4)
+    result[1, 1] = numpy.sum(x6 * (x1 + x12 * x8))
+    result[1, 2] = numpy.sum(x11 * x13)
+    result[2, 0] = numpy.sum(x15 * x4)
+    result[2, 1] = numpy.sum(x15 * x8)
+    result[2, 2] = numpy.sum(x6 * (x1 + x11 * x14))
+    return result
+
+
+def ovlp3d_12(ax, da, A, bx, db, B):
+    """Cartesian 3D (pd) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((3, 6), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = x0 * (ax * A[0] + bx * B[0])
+    x2 = -x1
+    x3 = x2 + A[0]
+    x4 = x2 + B[0]
+    x5 = x3 * x4
+    x6 = ax * bx * x0
+    x7 = (
+        5.568327996831708
+        * da
+        * db
+        * x0**1.5
+        * numpy.exp(-x6 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+    x8 = 1.732050807568877 * x7
+    x9 = 0.1666666666666667 * x8
+    x10 = x0 * (ax * A[1] + bx * B[1])
+    x11 = -x10
+    x12 = x11 + B[1]
+    x13 = 0.5 * x0
+    x14 = x7 * (x13 + x5)
+    x15 = x0 * (ax * A[2] + bx * B[2])
+    x16 = -x15
+    x17 = x16 + B[2]
+    x18 = x12**2 + x13
+    x19 = 0.3333333333333333 * x8
+    x20 = x19 * x3
+    x21 = x17 * x7
+    x22 = x13 + x17**2
+    x23 = x13 + x4**2
+    x24 = x11 + A[1]
+    x25 = x19 * x24
+    x26 = x12 * x24
+    x27 = x7 * (x13 + x26)
+    x28 = x16 + A[2]
+    x29 = x19 * x28
+    x30 = x17 * x28
+    x31 = x7 * (x13 + x30)
+
+    # 18 item(s)
+    result[0, 0] = numpy.sum(
+        -x9 * (x0 * (-2.0 * x1 + A[0] + B[0]) + x4 * (x0 + 2.0 * x5))
+    )
+    result[0, 1] = numpy.sum(-x12 * x14)
+    result[0, 2] = numpy.sum(-x14 * x17)
+    result[0, 3] = numpy.sum(-x18 * x20)
+    result[0, 4] = numpy.sum(-x12 * x21 * x3)
+    result[0, 5] = numpy.sum(-x20 * x22)
+    result[1, 0] = numpy.sum(-x23 * x25)
+    result[1, 1] = numpy.sum(-x27 * x4)
+    result[1, 2] = numpy.sum(-x21 * x24 * x4)
+    result[1, 3] = numpy.sum(
+        -x9 * (x0 * (-2.0 * x10 + A[1] + B[1]) + x12 * (x0 + 2.0 * x26))
+    )
+    result[1, 4] = numpy.sum(-x17 * x27)
+    result[1, 5] = numpy.sum(-x22 * x25)
+    result[2, 0] = numpy.sum(-x23 * x29)
+    result[2, 1] = numpy.sum(-x12 * x28 * x4 * x7)
+    result[2, 2] = numpy.sum(-x31 * x4)
+    result[2, 3] = numpy.sum(-x18 * x29)
+    result[2, 4] = numpy.sum(-x12 * x31)
+    result[2, 5] = numpy.sum(
+        -x9 * (x0 * (-2.0 * x15 + A[2] + B[2]) + x17 * (x0 + 2.0 * x30))
+    )
+    return result
+
+
+def ovlp3d_13(ax, da, A, bx, db, B):
+    """Cartesian 3D (pf) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((3, 10), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = x0 * (ax * A[0] + bx * B[0])
+    x2 = -x1
+    x3 = x2 + B[0]
+    x4 = x3**2
+    x5 = 3.0 * x0
+    x6 = x2 + A[0]
+    x7 = x3 * x6
+    x8 = x0 * (-2.0 * x1 + A[0] + B[0]) + x3 * (x0 + 2.0 * x7)
+    x9 = ax * bx * x0
+    x10 = (
+        5.568327996831708
+        * da
+        * db
+        * numpy.exp(-x9 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+    x11 = x0**1.5 * x10
+    x12 = 3.872983346207417 * x11
+    x13 = 0.01666666666666667 * x12
+    x14 = x0 * (ax * A[1] + bx * B[1])
+    x15 = -x14
+    x16 = x15 + B[1]
+    x17 = x11 * x16
+    x18 = 1.732050807568877
+    x19 = 0.1666666666666667 * x18
+    x20 = x19 * x8
+    x21 = x0 * (ax * A[2] + bx * B[2])
+    x22 = -x21
+    x23 = x22 + B[2]
+    x24 = x11 * x23
+    x25 = x16**2
+    x26 = 0.5 * x0
+    x27 = 0.3333333333333333 * x18
+    x28 = x27 * (x25 + x26)
+    x29 = x26 + x7
+    x30 = x0**1.5 * x10
+    x31 = x29 * x30
+    x32 = x23**2
+    x33 = x27 * (x26 + x32)
+    x34 = 0.06666666666666667 * x12
+    x35 = x34 * x6
+    x36 = 1.5 * x0
+    x37 = x16 * (x25 + x36)
+    x38 = x23 * (x32 + x36)
+    x39 = x15 + A[1]
+    x40 = x34 * x39
+    x41 = x3 * (x36 + x4)
+    x42 = x16 * x39
+    x43 = x26 + x42
+    x44 = x30 * x43
+    x45 = x27 * (x26 + x4)
+    x46 = x0 * (-2.0 * x14 + A[1] + B[1]) + x16 * (x0 + 2.0 * x42)
+    x47 = x19 * x46
+    x48 = x11 * x3
+    x49 = x22 + A[2]
+    x50 = x34 * x49
+    x51 = x23 * x49
+    x52 = x26 + x51
+    x53 = x30 * x52
+    x54 = x0 * (-2.0 * x21 + A[2] + B[2]) + x23 * (x0 + 2.0 * x51)
+    x55 = x19 * x54
+
+    # 30 item(s)
+    result[0, 0] = numpy.sum(x13 * (x0 * (2.0 * x4 + x5 + 4.0 * x7) + 2.0 * x3 * x8))
+    result[0, 1] = numpy.sum(x17 * x20)
+    result[0, 2] = numpy.sum(x20 * x24)
+    result[0, 3] = numpy.sum(x28 * x31)
+    result[0, 4] = numpy.sum(x16 * x24 * x29)
+    result[0, 5] = numpy.sum(x31 * x33)
+    result[0, 6] = numpy.sum(x35 * x37)
+    result[0, 7] = numpy.sum(x24 * x28 * x6)
+    result[0, 8] = numpy.sum(x17 * x33 * x6)
+    result[0, 9] = numpy.sum(x35 * x38)
+    result[1, 0] = numpy.sum(x40 * x41)
+    result[1, 1] = numpy.sum(x44 * x45)
+    result[1, 2] = numpy.sum(x24 * x39 * x45)
+    result[1, 3] = numpy.sum(x47 * x48)
+    result[1, 4] = numpy.sum(x24 * x3 * x43)
+    result[1, 5] = numpy.sum(x33 * x39 * x48)
+    result[1, 6] = numpy.sum(x13 * (x0 * (2.0 * x25 + 4.0 * x42 + x5) + 2.0 * x16 * x46))
+    result[1, 7] = numpy.sum(x24 * x47)
+    result[1, 8] = numpy.sum(x33 * x44)
+    result[1, 9] = numpy.sum(x38 * x40)
+    result[2, 0] = numpy.sum(x41 * x50)
+    result[2, 1] = numpy.sum(x17 * x45 * x49)
+    result[2, 2] = numpy.sum(x45 * x53)
+    result[2, 3] = numpy.sum(x28 * x48 * x49)
+    result[2, 4] = numpy.sum(x17 * x3 * x52)
+    result[2, 5] = numpy.sum(x48 * x55)
+    result[2, 6] = numpy.sum(x37 * x50)
+    result[2, 7] = numpy.sum(x28 * x53)
+    result[2, 8] = numpy.sum(x17 * x55)
+    result[2, 9] = numpy.sum(x13 * (x0 * (2.0 * x32 + x5 + 4.0 * x51) + 2.0 * x23 * x54))
+    return result
+
+
+def ovlp3d_14(ax, da, A, bx, db, B):
+    """Cartesian 3D (pg) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((3, 15), dtype=float)
+
+    x0 = 0.5 / (ax + bx)
+    x1 = (ax + bx) ** (-1.0)
+    x2 = -x1 * (ax * A[0] + bx * B[0])
+    x3 = -x2 - A[0]
+    x4 = ax * bx * x1
+    x5 = numpy.exp(-x4 * (A[0] - B[0]) ** 2)
+    x6 = 1.772453850905516 * numpy.sqrt(x1)
+    x7 = x5 * x6
+    x8 = x3 * x7
+    x9 = -x2 - B[0]
+    x10 = x7 * x9
+    x11 = x0 * (x10 + x8)
+    x12 = x0 * x7
+    x13 = x8 * x9
+    x14 = x12 + x13
+    x15 = x14 * x9
+    x16 = x7 * x9**2
+    x17 = x12 + x16
+    x18 = x9 * (2.0 * x12 + x17)
+    x19 = 3.0 * x12
+    x20 = x11 + x15
+    x21 = x0 * (2.0 * x13 + x16 + x19) + x20 * x9
+    x22 = numpy.exp(-x4 * (A[1] - B[1]) ** 2)
+    x23 = da * db
+    x24 = numpy.exp(-x4 * (A[2] - B[2]) ** 2)
+    x25 = 3.141592653589793 * x1 * x24
+    x26 = x23 * x25
+    x27 = x22 * x26
+    x28 = 0.09759000729485332
+    x29 = x27 * x28
+    x30 = -x1 * (ax * A[1] + bx * B[1])
+    x31 = -x30 - B[1]
+    x32 = 0.2581988897471611
+    x33 = x27 * x32
+    x34 = x21 * x33
+    x35 = -x1 * (ax * A[2] + bx * B[2])
+    x36 = -x35 - B[2]
+    x37 = x22 * x6
+    x38 = x31**2 * x37
+    x39 = x0 * x37
+    x40 = x38 + x39
+    x41 = x24 * x6
+    x42 = 0.3333333333333333 * x23
+    x43 = x20 * x42
+    x44 = 1.732050807568877
+    x45 = x31 * x44
+    x46 = x25 * x36
+    x47 = x36**2 * x41
+    x48 = x0 * x41
+    x49 = x47 + x48
+    x50 = x31 * (2.0 * x39 + x40)
+    x51 = x23 * x32
+    x52 = x14 * x51
+    x53 = x36 * x41
+    x54 = x40 * x42
+    x55 = x14 * x44
+    x56 = x31 * x37
+    x57 = x42 * x49
+    x58 = x36 * (2.0 * x48 + x49)
+    x59 = 3.0 * x39
+    x60 = x28 * x5
+    x61 = x26 * x60
+    x62 = x61 * (x0 * (3.0 * x38 + x59) + x31 * x50)
+    x63 = x36 * x5
+    x64 = x26 * x32
+    x65 = x50 * x64
+    x66 = x31 * x5
+    x67 = 3.141592653589793 * x1 * x22
+    x68 = x51 * x67
+    x69 = x58 * x68
+    x70 = 3.0 * x48
+    x71 = x23 * x60 * x67
+    x72 = x71 * (x0 * (3.0 * x47 + x70) + x36 * x58)
+    x73 = -x30 - A[1]
+    x74 = x29 * (x0 * (3.0 * x16 + x19) + x18 * x9)
+    x75 = x37 * x73
+    x76 = x31 * x75
+    x77 = x39 + x76
+    x78 = x51 * x77
+    x79 = x18 * x33
+    x80 = x0 * (x56 + x75)
+    x81 = x31 * x77
+    x82 = x80 + x81
+    x83 = x42 * x82
+    x84 = x44 * x77
+    x85 = x17 * x42
+    x86 = x5 * x9
+    x87 = x0 * (x38 + x59 + 2.0 * x76) + x31 * x82
+    x88 = x64 * x87
+    x89 = -x35 - A[2]
+    x90 = x41 * x89
+    x91 = x36 * x90
+    x92 = x48 + x91
+    x93 = x51 * x92
+    x94 = x44 * x92
+    x95 = x0 * (x53 + x90)
+    x96 = x36 * x92
+    x97 = x95 + x96
+    x98 = x42 * x97
+    x99 = x0 * (x47 + x70 + 2.0 * x91) + x36 * x97
+    x100 = x68 * x99
+
+    # 45 item(s)
+    result[0, 0] = numpy.sum(x29 * (x0 * (3.0 * x11 + 3.0 * x15 + x18) + x21 * x9))
+    result[0, 1] = numpy.sum(x31 * x34)
+    result[0, 2] = numpy.sum(x34 * x36)
+    result[0, 3] = numpy.sum(x40 * x41 * x43)
+    result[0, 4] = numpy.sum(x22 * x43 * x45 * x46)
+    result[0, 5] = numpy.sum(x37 * x43 * x49)
+    result[0, 6] = numpy.sum(x41 * x50 * x52)
+    result[0, 7] = numpy.sum(x53 * x54 * x55)
+    result[0, 8] = numpy.sum(x55 * x56 * x57)
+    result[0, 9] = numpy.sum(x37 * x52 * x58)
+    result[0, 10] = numpy.sum(x3 * x62)
+    result[0, 11] = numpy.sum(x3 * x63 * x65)
+    result[0, 12] = numpy.sum(x40 * x57 * x8)
+    result[0, 13] = numpy.sum(x3 * x66 * x69)
+    result[0, 14] = numpy.sum(x3 * x72)
+    result[1, 0] = numpy.sum(x73 * x74)
+    result[1, 1] = numpy.sum(x18 * x41 * x78)
+    result[1, 2] = numpy.sum(x36 * x73 * x79)
+    result[1, 3] = numpy.sum(x17 * x41 * x83)
+    result[1, 4] = numpy.sum(x53 * x84 * x85)
+    result[1, 5] = numpy.sum(x17 * x57 * x75)
+    result[1, 6] = numpy.sum(x86 * x88)
+    result[1, 7] = numpy.sum(x44 * x46 * x83 * x86)
+    result[1, 8] = numpy.sum(x10 * x57 * x84)
+    result[1, 9] = numpy.sum(x69 * x73 * x86)
+    result[1, 10] = numpy.sum(x61 * (x0 * (x50 + 3.0 * x80 + 3.0 * x81) + x31 * x87))
+    result[1, 11] = numpy.sum(x63 * x88)
+    result[1, 12] = numpy.sum(x49 * x7 * x83)
+    result[1, 13] = numpy.sum(x58 * x7 * x78)
+    result[1, 14] = numpy.sum(x72 * x73)
+    result[2, 0] = numpy.sum(x74 * x89)
+    result[2, 1] = numpy.sum(x31 * x79 * x89)
+    result[2, 2] = numpy.sum(x18 * x37 * x93)
+    result[2, 3] = numpy.sum(x17 * x54 * x90)
+    result[2, 4] = numpy.sum(x56 * x85 * x94)
+    result[2, 5] = numpy.sum(x17 * x37 * x98)
+    result[2, 6] = numpy.sum(x65 * x86 * x89)
+    result[2, 7] = numpy.sum(x10 * x54 * x94)
+    result[2, 8] = numpy.sum(x45 * x67 * x86 * x98)
+    result[2, 9] = numpy.sum(x100 * x86)
+    result[2, 10] = numpy.sum(x62 * x89)
+    result[2, 11] = numpy.sum(x50 * x7 * x93)
+    result[2, 12] = numpy.sum(x40 * x7 * x98)
+    result[2, 13] = numpy.sum(x100 * x66)
+    result[2, 14] = numpy.sum(x71 * (x0 * (x58 + 3.0 * x95 + 3.0 * x96) + x36 * x99))
+    return result
+
+
+def ovlp3d_20(ax, da, A, bx, db, B):
+    """Cartesian 3D (ds) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((6, 1), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = -x0 * (ax * A[0] + bx * B[0]) + A[0]
+    x2 = 0.5 * x0
+    x3 = ax * bx * x0
+    x4 = (
+        5.568327996831708
+        * da
+        * db
+        * x0**1.5
+        * numpy.exp(-x3 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+    x5 = 0.5773502691896258 * x4
+    x6 = -x0 * (ax * A[1] + bx * B[1]) + A[1]
+    x7 = x1 * x4
+    x8 = -x0 * (ax * A[2] + bx * B[2]) + A[2]
+
+    # 6 item(s)
+    result[0, 0] = numpy.sum(x5 * (x1**2 + x2))
+    result[1, 0] = numpy.sum(x6 * x7)
+    result[2, 0] = numpy.sum(x7 * x8)
+    result[3, 0] = numpy.sum(x5 * (x2 + x6**2))
+    result[4, 0] = numpy.sum(x4 * x6 * x8)
+    result[5, 0] = numpy.sum(x5 * (x2 + x8**2))
+    return result
+
+
+def ovlp3d_21(ax, da, A, bx, db, B):
+    """Cartesian 3D (dp) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((6, 3), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = x0 * (ax * A[0] + bx * B[0])
+    x2 = -x1
+    x3 = x2 + A[0]
+    x4 = x2 + B[0]
+    x5 = x3 * x4
+    x6 = ax * bx * x0
+    x7 = (
+        5.568327996831708
+        * da
+        * db
+        * x0**1.5
+        * numpy.exp(-x6 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+    x8 = 1.732050807568877 * x7
+    x9 = 0.1666666666666667 * x8
+    x10 = x0 * (ax * A[1] + bx * B[1])
+    x11 = -x10
+    x12 = x11 + B[1]
+    x13 = 0.5 * x0
+    x14 = 0.3333333333333333 * x8
+    x15 = x14 * (x13 + x3**2)
+    x16 = x0 * (ax * A[2] + bx * B[2])
+    x17 = -x16
+    x18 = x17 + B[2]
+    x19 = x11 + A[1]
+    x20 = x7 * (x13 + x5)
+    x21 = x12 * x19
+    x22 = x13 + x21
+    x23 = x3 * x7
+    x24 = x17 + A[2]
+    x25 = x18 * x24
+    x26 = x13 + x25
+    x27 = x14 * (x13 + x19**2)
+    x28 = x24 * x7
+    x29 = x14 * (x13 + x24**2)
+
+    # 18 item(s)
+    result[0, 0] = numpy.sum(
+        -x9 * (x0 * (-2.0 * x1 + A[0] + B[0]) + x3 * (x0 + 2.0 * x5))
+    )
+    result[0, 1] = numpy.sum(-x12 * x15)
+    result[0, 2] = numpy.sum(-x15 * x18)
+    result[1, 0] = numpy.sum(-x19 * x20)
+    result[1, 1] = numpy.sum(-x22 * x23)
+    result[1, 2] = numpy.sum(-x18 * x19 * x23)
+    result[2, 0] = numpy.sum(-x20 * x24)
+    result[2, 1] = numpy.sum(-x12 * x23 * x24)
+    result[2, 2] = numpy.sum(-x23 * x26)
+    result[3, 0] = numpy.sum(-x27 * x4)
+    result[3, 1] = numpy.sum(
+        -x9 * (x0 * (-2.0 * x10 + A[1] + B[1]) + x19 * (x0 + 2.0 * x21))
+    )
+    result[3, 2] = numpy.sum(-x18 * x27)
+    result[4, 0] = numpy.sum(-x19 * x28 * x4)
+    result[4, 1] = numpy.sum(-x22 * x28)
+    result[4, 2] = numpy.sum(-x19 * x26 * x7)
+    result[5, 0] = numpy.sum(-x29 * x4)
+    result[5, 1] = numpy.sum(-x12 * x29)
+    result[5, 2] = numpy.sum(
+        -x9 * (x0 * (-2.0 * x16 + A[2] + B[2]) + x24 * (x0 + 2.0 * x25))
+    )
+    return result
+
+
+def ovlp3d_22(ax, da, A, bx, db, B):
+    """Cartesian 3D (dd) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((6, 6), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = x0 * (ax * A[0] + bx * B[0])
+    x2 = -x1
+    x3 = x2 + B[0]
+    x4 = x3**2
+    x5 = 3.0 * x0
+    x6 = x2 + A[0]
+    x7 = x3 * x6
+    x8 = x0 * (-2.0 * x1 + A[0] + B[0])
+    x9 = x0 + 2.0 * x7
+    x10 = x3 * x9 + x8
+    x11 = ax * bx * x0
+    x12 = (
+        5.568327996831708
+        * da
+        * db
+        * numpy.exp(-x11 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+    x13 = x0**1.5 * x12
+    x14 = 0.08333333333333333 * x13
+    x15 = x0 * (ax * A[1] + bx * B[1])
+    x16 = -x15
+    x17 = x16 + B[1]
+    x18 = x13 * x17
+    x19 = 1.732050807568877
+    x20 = 0.1666666666666667 * x19
+    x21 = x20 * (x6 * x9 + x8)
+    x22 = x0 * (ax * A[2] + bx * B[2])
+    x23 = -x22
+    x24 = x23 + B[2]
+    x25 = x13 * x24
+    x26 = x17**2
+    x27 = 0.5 * x0
+    x28 = x26 + x27
+    x29 = x27 + x6**2
+    x30 = x0**1.5 * x12
+    x31 = 0.3333333333333333 * x30
+    x32 = x29 * x31
+    x33 = 0.3333333333333333 * x19
+    x34 = x25 * x33
+    x35 = x24**2
+    x36 = x27 + x35
+    x37 = x16 + A[1]
+    x38 = x13 * x20
+    x39 = x10 * x38
+    x40 = x17 * x37
+    x41 = x27 + x40
+    x42 = x27 + x7
+    x43 = x30 * x42
+    x44 = x0 * (-2.0 * x15 + A[1] + B[1])
+    x45 = x0 + 2.0 * x40
+    x46 = x17 * x45 + x44
+    x47 = x38 * x6
+    x48 = x13 * x33 * x6
+    x49 = x23 + A[2]
+    x50 = x24 * x49
+    x51 = x27 + x50
+    x52 = x0 * (-2.0 * x22 + A[2] + B[2])
+    x53 = x0 + 2.0 * x50
+    x54 = x24 * x53 + x52
+    x55 = x27 + x4
+    x56 = x27 + x37**2
+    x57 = x31 * x56
+    x58 = x13 * x3
+    x59 = x20 * (x37 * x45 + x44)
+    x60 = x27 + x49**2
+    x61 = x31 * x60
+    x62 = x20 * (x49 * x53 + x52)
+
+    # 36 item(s)
+    result[0, 0] = numpy.sum(x14 * (x0 * (2.0 * x4 + x5 + 4.0 * x7) + 2.0 * x10 * x6))
+    result[0, 1] = numpy.sum(x18 * x21)
+    result[0, 2] = numpy.sum(x21 * x25)
+    result[0, 3] = numpy.sum(x28 * x32)
+    result[0, 4] = numpy.sum(x17 * x29 * x34)
+    result[0, 5] = numpy.sum(x32 * x36)
+    result[1, 0] = numpy.sum(x37 * x39)
+    result[1, 1] = numpy.sum(x41 * x43)
+    result[1, 2] = numpy.sum(x25 * x37 * x42)
+    result[1, 3] = numpy.sum(x46 * x47)
+    result[1, 4] = numpy.sum(x25 * x41 * x6)
+    result[1, 5] = numpy.sum(x36 * x37 * x48)
+    result[2, 0] = numpy.sum(x39 * x49)
+    result[2, 1] = numpy.sum(x18 * x42 * x49)
+    result[2, 2] = numpy.sum(x43 * x51)
+    result[2, 3] = numpy.sum(x28 * x48 * x49)
+    result[2, 4] = numpy.sum(x18 * x51 * x6)
+    result[2, 5] = numpy.sum(x47 * x54)
+    result[3, 0] = numpy.sum(x55 * x57)
+    result[3, 1] = numpy.sum(x58 * x59)
+    result[3, 2] = numpy.sum(x3 * x34 * x56)
+    result[3, 3] = numpy.sum(x14 * (x0 * (2.0 * x26 + 4.0 * x40 + x5) + 2.0 * x37 * x46))
+    result[3, 4] = numpy.sum(x25 * x59)
+    result[3, 5] = numpy.sum(x36 * x57)
+    result[4, 0] = numpy.sum(x13 * x33 * x37 * x49 * x55)
+    result[4, 1] = numpy.sum(x41 * x49 * x58)
+    result[4, 2] = numpy.sum(x37 * x51 * x58)
+    result[4, 3] = numpy.sum(x38 * x46 * x49)
+    result[4, 4] = numpy.sum(x30 * x41 * x51)
+    result[4, 5] = numpy.sum(x37 * x38 * x54)
+    result[5, 0] = numpy.sum(x55 * x61)
+    result[5, 1] = numpy.sum(x18 * x3 * x33 * x60)
+    result[5, 2] = numpy.sum(x58 * x62)
+    result[5, 3] = numpy.sum(x28 * x61)
+    result[5, 4] = numpy.sum(x18 * x62)
+    result[5, 5] = numpy.sum(x14 * (x0 * (2.0 * x35 + x5 + 4.0 * x50) + 2.0 * x49 * x54))
+    return result
+
+
+def ovlp3d_23(ax, da, A, bx, db, B):
+    """Cartesian 3D (df) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((6, 10), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = x0 * (ax * A[0] + bx * B[0])
+    x2 = -x1
+    x3 = x2 + B[0]
+    x4 = x3**2
+    x5 = 3.0 * x0
+    x6 = x2 + A[0]
+    x7 = x3 * x6
+    x8 = x0 * (2.0 * x4 + x5 + 4.0 * x7)
+    x9 = x0 * (-2.0 * x1 + A[0] + B[0])
+    x10 = x0 + 2.0 * x7
+    x11 = x10 * x3
+    x12 = x11 + x9
+    x13 = 2.0 * x12
+    x14 = x13 * x6 + x8
+    x15 = x10 * x6
+    x16 = 2.0 * x0
+    x17 = 2.23606797749979
+    x18 = ax * bx * x0
+    x19 = (
+        5.568327996831708
+        * da
+        * db
+        * numpy.exp(-x18 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+    x20 = x0**1.5 * x19
+    x21 = 0.01666666666666667 * x20
+    x22 = x17 * x21
+    x23 = x0 * (ax * A[1] + bx * B[1])
+    x24 = -x23
+    x25 = x24 + B[1]
+    x26 = 0.08333333333333333 * x20
+    x27 = x14 * x26
+    x28 = x0 * (ax * A[2] + bx * B[2])
+    x29 = -x28
+    x30 = x29 + B[2]
+    x31 = x25**2
+    x32 = 0.5 * x0
+    x33 = x31 + x32
+    x34 = x15 + x9
+    x35 = x0**1.5 * x19
+    x36 = 0.1666666666666667 * x35
+    x37 = x34 * x36
+    x38 = 1.732050807568877
+    x39 = 0.1666666666666667 * x20 * x38
+    x40 = x30 * x39
+    x41 = x30**2
+    x42 = x32 + x41
+    x43 = 1.5 * x0
+    x44 = x31 + x43
+    x45 = x25 * x44
+    x46 = x32 + x6**2
+    x47 = 0.06666666666666667 * x17
+    x48 = x35 * x47
+    x49 = x46 * x48
+    x50 = 0.3333333333333333 * x35
+    x51 = x46 * x50
+    x52 = x41 + x43
+    x53 = x30 * x52
+    x54 = x24 + A[1]
+    x55 = 3.872983346207417
+    x56 = x21 * x55
+    x57 = x56 * (x13 * x3 + x8)
+    x58 = x25 * x54
+    x59 = x32 + x58
+    x60 = x36 * x38
+    x61 = x12 * x60
+    x62 = x0 * (-2.0 * x23 + A[1] + B[1])
+    x63 = x0 + 2.0 * x58
+    x64 = x25 * x63
+    x65 = x62 + x64
+    x66 = x32 + x7
+    x67 = x60 * x66
+    x68 = x35 * x66
+    x69 = x38 * x42
+    x70 = 0.3333333333333333 * x68
+    x71 = x0 * (2.0 * x31 + x5 + 4.0 * x58)
+    x72 = 2.0 * x65
+    x73 = x25 * x72 + x71
+    x74 = x56 * x6
+    x75 = x50 * x6
+    x76 = 0.06666666666666667 * x20 * x55 * x6
+    x77 = x29 + A[2]
+    x78 = x25 * x39
+    x79 = x30 * x77
+    x80 = x32 + x79
+    x81 = x33 * x38
+    x82 = x0 * (-2.0 * x28 + A[2] + B[2])
+    x83 = x0 + 2.0 * x79
+    x84 = x30 * x83
+    x85 = x82 + x84
+    x86 = x0 * (2.0 * x41 + x5 + 4.0 * x79)
+    x87 = 2.0 * x85
+    x88 = x30 * x87 + x86
+    x89 = x32 + x54**2
+    x90 = x4 + x43
+    x91 = x3 * x35
+    x92 = x47 * x90 * x91
+    x93 = x32 + x4
+    x94 = x54 * x63
+    x95 = x62 + x94
+    x96 = x36 * x95
+    x97 = x50 * x93
+    x98 = x30 * x89
+    x99 = x54 * x72 + x71
+    x100 = x26 * x99
+    x101 = 0.3333333333333333 * x91
+    x102 = x38 * x97
+    x103 = x3 * x39
+    x104 = x32 + x77**2
+    x105 = x104 * x25
+    x106 = x77 * x83
+    x107 = x106 + x82
+    x108 = x107 * x36
+    x109 = x77 * x87 + x86
+    x110 = x109 * x26
+
+    # 60 item(s)
+    result[0, 0] = numpy.sum(-x22 * (x14 * x3 + x16 * (x11 + x15 + 2.0 * x9)))
+    result[0, 1] = numpy.sum(-x25 * x27)
+    result[0, 2] = numpy.sum(-x27 * x30)
+    result[0, 3] = numpy.sum(-x33 * x37)
+    result[0, 4] = numpy.sum(-x25 * x34 * x40)
+    result[0, 5] = numpy.sum(-x37 * x42)
+    result[0, 6] = numpy.sum(-x45 * x49)
+    result[0, 7] = numpy.sum(-x30 * x33 * x51)
+    result[0, 8] = numpy.sum(-x25 * x42 * x51)
+    result[0, 9] = numpy.sum(-x49 * x53)
+    result[1, 0] = numpy.sum(-x54 * x57)
+    result[1, 1] = numpy.sum(-x59 * x61)
+    result[1, 2] = numpy.sum(-x12 * x40 * x54)
+    result[1, 3] = numpy.sum(-x65 * x67)
+    result[1, 4] = numpy.sum(-x30 * x59 * x68)
+    result[1, 5] = numpy.sum(-x54 * x69 * x70)
+    result[1, 6] = numpy.sum(-x73 * x74)
+    result[1, 7] = numpy.sum(-x40 * x6 * x65)
+    result[1, 8] = numpy.sum(-x59 * x69 * x75)
+    result[1, 9] = numpy.sum(-x53 * x54 * x76)
+    result[2, 0] = numpy.sum(-x57 * x77)
+    result[2, 1] = numpy.sum(-x12 * x77 * x78)
+    result[2, 2] = numpy.sum(-x61 * x80)
+    result[2, 3] = numpy.sum(-x70 * x77 * x81)
+    result[2, 4] = numpy.sum(-x25 * x68 * x80)
+    result[2, 5] = numpy.sum(-x67 * x85)
+    result[2, 6] = numpy.sum(-x45 * x76 * x77)
+    result[2, 7] = numpy.sum(-x75 * x80 * x81)
+    result[2, 8] = numpy.sum(-x6 * x78 * x85)
+    result[2, 9] = numpy.sum(-x74 * x88)
+    result[3, 0] = numpy.sum(-x89 * x92)
+    result[3, 1] = numpy.sum(-x93 * x96)
+    result[3, 2] = numpy.sum(-x97 * x98)
+    result[3, 3] = numpy.sum(-x100 * x3)
+    result[3, 4] = numpy.sum(-x3 * x40 * x95)
+    result[3, 5] = numpy.sum(-x101 * x42 * x89)
+    result[3, 6] = numpy.sum(-x22 * (x16 * (2.0 * x62 + x64 + x94) + x25 * x99))
+    result[3, 7] = numpy.sum(-x100 * x30)
+    result[3, 8] = numpy.sum(-x42 * x96)
+    result[3, 9] = numpy.sum(-x48 * x52 * x98)
+    result[4, 0] = numpy.sum(-0.06666666666666667 * x20 * x3 * x54 * x55 * x77 * x90)
+    result[4, 1] = numpy.sum(-x102 * x59 * x77)
+    result[4, 2] = numpy.sum(-x102 * x54 * x80)
+    result[4, 3] = numpy.sum(-x103 * x65 * x77)
+    result[4, 4] = numpy.sum(-x59 * x80 * x91)
+    result[4, 5] = numpy.sum(-x103 * x54 * x85)
+    result[4, 6] = numpy.sum(-x56 * x73 * x77)
+    result[4, 7] = numpy.sum(-x60 * x65 * x80)
+    result[4, 8] = numpy.sum(-x59 * x60 * x85)
+    result[4, 9] = numpy.sum(-x54 * x56 * x88)
+    result[5, 0] = numpy.sum(-x104 * x92)
+    result[5, 1] = numpy.sum(-x105 * x97)
+    result[5, 2] = numpy.sum(-x108 * x93)
+    result[5, 3] = numpy.sum(-x101 * x104 * x33)
+    result[5, 4] = numpy.sum(-x107 * x3 * x78)
+    result[5, 5] = numpy.sum(-x110 * x3)
+    result[5, 6] = numpy.sum(-x105 * x44 * x48)
+    result[5, 7] = numpy.sum(-x108 * x33)
+    result[5, 8] = numpy.sum(-x110 * x25)
+    result[5, 9] = numpy.sum(-x22 * (x109 * x30 + x16 * (x106 + 2.0 * x82 + x84)))
+    return result
+
+
+def ovlp3d_24(ax, da, A, bx, db, B):
+    """Cartesian 3D (dg) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((6, 15), dtype=float)
+
+    x0 = 0.5 / (ax + bx)
+    x1 = (ax + bx) ** (-1.0)
+    x2 = -x1 * (ax * A[0] + bx * B[0])
+    x3 = -x2 - B[0]
+    x4 = 1.772453850905516 * numpy.sqrt(x1)
+    x5 = -x2 - A[0]
+    x6 = ax * bx * x1
+    x7 = numpy.exp(-x6 * (A[0] - B[0]) ** 2)
+    x8 = x5 * x7
+    x9 = x4 * x8
+    x10 = x4 * x7
+    x11 = x10 * x3
+    x12 = x0 * (x11 + x9)
+    x13 = x0 * x10
+    x14 = x3 * x9
+    x15 = x13 + x14
+    x16 = x15 * x3
+    x17 = x12 + x16
+    x18 = x17 * x3
+    x19 = x17 * x5
+    x20 = x10 * x3**2
+    x21 = 3.0 * x13
+    x22 = x0 * (2.0 * x14 + x20 + x21)
+    x23 = x15 * x5
+    x24 = x19 + x22
+    x25 = 2.0 * x0 * (2.0 * x12 + x16 + x23) + x24 * x3
+    x26 = da * db
+    x27 = 0.0563436169819011
+    x28 = x26 * x27
+    x29 = numpy.exp(-x6 * (A[1] - B[1]) ** 2)
+    x30 = numpy.exp(-x6 * (A[2] - B[2]) ** 2)
+    x31 = 3.141592653589793 * x1 * x30
+    x32 = x29 * x31
+    x33 = -x1 * (ax * A[1] + bx * B[1])
+    x34 = -x33 - B[1]
+    x35 = x32 * x34
+    x36 = 2.23606797749979
+    x37 = 0.06666666666666667 * x26
+    x38 = x36 * x37
+    x39 = x25 * x38
+    x40 = -x1 * (ax * A[2] + bx * B[2])
+    x41 = -x40 - B[2]
+    x42 = x32 * x41
+    x43 = x30 * x4
+    x44 = x29 * x4
+    x45 = x34**2 * x44
+    x46 = x0 * x44
+    x47 = x45 + x46
+    x48 = 1.732050807568877 * x26
+    x49 = 0.1111111111111111 * x47 * x48
+    x50 = 0.3333333333333333 * x26
+    x51 = x41 * x50
+    x52 = x41**2 * x43
+    x53 = x0 * x43
+    x54 = x52 + x53
+    x55 = x48 * x54
+    x56 = 0.1111111111111111 * x55
+    x57 = x34 * (2.0 * x46 + x47)
+    x58 = x26 * x43
+    x59 = 0.06666666666666667 * x58
+    x60 = x12 + x23
+    x61 = x36 * x60
+    x62 = x41 * x43
+    x63 = x26 * x47
+    x64 = 0.3333333333333333 * x60
+    x65 = x34 * x44
+    x66 = x26 * x54
+    x67 = x41 * (2.0 * x53 + x54)
+    x68 = x37 * x44
+    x69 = x10 * x5**2 + x13
+    x70 = 3.0 * x46
+    x71 = x0 * (3.0 * x45 + x70) + x34 * x57
+    x72 = x27 * x58
+    x73 = x38 * x69
+    x74 = 3.0 * x53
+    x75 = x0 * (3.0 * x52 + x74) + x41 * x67
+    x76 = x28 * x75
+    x77 = -x33 - A[1]
+    x78 = 0.09759000729485332 * x26
+    x79 = x77 * x78
+    x80 = x13 + x20
+    x81 = 2.0 * x0 * x11 + x3 * x80
+    x82 = x18 + x22
+    x83 = x32 * (x0 * (3.0 * x12 + 3.0 * x16 + x81) + x3 * x82)
+    x84 = x44 * x77
+    x85 = x34 * x84
+    x86 = x46 + x85
+    x87 = 3.872983346207417
+    x88 = x59 * x87
+    x89 = x37 * x87
+    x90 = x82 * x89
+    x91 = x0 * (x65 + x84)
+    x92 = x34 * x86
+    x93 = x91 + x92
+    x94 = 0.3333333333333333 * x17
+    x95 = x48 * x62
+    x96 = x0 * (x45 + x70 + 2.0 * x85)
+    x97 = x34 * x93
+    x98 = x96 + x97
+    x99 = 0.3333333333333333 * x15
+    x100 = x67 * x89
+    x101 = x78 * x8
+    x102 = x31 * (x0 * (x57 + 3.0 * x91 + 3.0 * x92) + x34 * x98)
+    x103 = x31 * x41
+    x104 = x8 * x89
+    x105 = 0.3333333333333333 * x93
+    x106 = 3.141592653589793 * x1 * x29
+    x107 = -x40 - A[2]
+    x108 = x107 * x78
+    x109 = x107 * x43
+    x110 = x109 * x41
+    x111 = x110 + x53
+    x112 = x68 * x87
+    x113 = x111 * x48
+    x114 = x0 * (x109 + x62)
+    x115 = x111 * x41
+    x116 = x114 + x115
+    x117 = x116 * x26
+    x118 = x57 * x89
+    x119 = x116 * x48
+    x120 = x0 * (2.0 * x110 + x52 + x74)
+    x121 = x116 * x41
+    x122 = x120 + x121
+    x123 = x106 * x34
+    x124 = x106 * (x0 * (3.0 * x114 + 3.0 * x115 + x67) + x122 * x41)
+    x125 = x44 * x77**2 + x46
+    x126 = x0 * (3.0 * x20 + x21) + x3 * x81
+    x127 = x77 * x86
+    x128 = x127 + x91
+    x129 = x128 * x36
+    x130 = x125 * x38
+    x131 = x77 * x93
+    x132 = x131 + x96
+    x133 = 0.1111111111111111 * x48 * x80
+    x134 = 0.3333333333333333 * x80
+    x135 = x134 * x26
+    x136 = x3 * x7
+    x137 = x136 * x31
+    x138 = 2.0 * x0 * (x127 + 2.0 * x91 + x92) + x132 * x34
+    x139 = x138 * x38
+    x140 = 0.3333333333333333 * x11
+    x141 = x28 * x7
+    x142 = x10 * x37
+    x143 = x81 * x89
+    x144 = x106 * x136
+    x145 = x142 * x87
+    x146 = x107**2 * x43 + x53
+    x147 = x146 * x28
+    x148 = x146 * x38
+    x149 = x107 * x111
+    x150 = x114 + x149
+    x151 = x150 * x36
+    x152 = x107 * x116
+    x153 = x120 + x152
+    x154 = 2.0 * x0 * (2.0 * x114 + x115 + x149) + x153 * x41
+    x155 = x154 * x38
+
+    # 90 item(s)
+    result[0, 0] = numpy.sum(
+        x28 * x32 * (x0 * (2.0 * x18 + 3.0 * x19 + 5.0 * x22) + x25 * x3)
+    )
+    result[0, 1] = numpy.sum(x35 * x39)
+    result[0, 2] = numpy.sum(x39 * x42)
+    result[0, 3] = numpy.sum(x24 * x43 * x49)
+    result[0, 4] = numpy.sum(x24 * x35 * x51)
+    result[0, 5] = numpy.sum(x24 * x44 * x56)
+    result[0, 6] = numpy.sum(x57 * x59 * x61)
+    result[0, 7] = numpy.sum(x62 * x63 * x64)
+    result[0, 8] = numpy.sum(x64 * x65 * x66)
+    result[0, 9] = numpy.sum(x61 * x67 * x68)
+    result[0, 10] = numpy.sum(x69 * x71 * x72)
+    result[0, 11] = numpy.sum(x57 * x62 * x73)
+    result[0, 12] = numpy.sum(x47 * x56 * x69)
+    result[0, 13] = numpy.sum(x65 * x67 * x73)
+    result[0, 14] = numpy.sum(x44 * x69 * x76)
+    result[1, 0] = numpy.sum(x79 * x83)
+    result[1, 1] = numpy.sum(x82 * x86 * x88)
+    result[1, 2] = numpy.sum(x42 * x77 * x90)
+    result[1, 3] = numpy.sum(x58 * x93 * x94)
+    result[1, 4] = numpy.sum(x86 * x94 * x95)
+    result[1, 5] = numpy.sum(x66 * x84 * x94)
+    result[1, 6] = numpy.sum(x15 * x88 * x98)
+    result[1, 7] = numpy.sum(x93 * x95 * x99)
+    result[1, 8] = numpy.sum(x55 * x86 * x99)
+    result[1, 9] = numpy.sum(x100 * x15 * x84)
+    result[1, 10] = numpy.sum(x101 * x102)
+    result[1, 11] = numpy.sum(x103 * x104 * x98)
+    result[1, 12] = numpy.sum(x105 * x66 * x9)
+    result[1, 13] = numpy.sum(x100 * x86 * x9)
+    result[1, 14] = numpy.sum(x106 * x75 * x79 * x8)
+    result[2, 0] = numpy.sum(x108 * x83)
+    result[2, 1] = numpy.sum(x107 * x35 * x90)
+    result[2, 2] = numpy.sum(x111 * x112 * x82)
+    result[2, 3] = numpy.sum(x109 * x63 * x94)
+    result[2, 4] = numpy.sum(x113 * x65 * x94)
+    result[2, 5] = numpy.sum(x117 * x44 * x94)
+    result[2, 6] = numpy.sum(x109 * x118 * x15)
+    result[2, 7] = numpy.sum(x113 * x47 * x99)
+    result[2, 8] = numpy.sum(x119 * x65 * x99)
+    result[2, 9] = numpy.sum(x112 * x122 * x15)
+    result[2, 10] = numpy.sum(x101 * x107 * x31 * x71)
+    result[2, 11] = numpy.sum(x111 * x118 * x9)
+    result[2, 12] = numpy.sum(0.3333333333333333 * x117 * x47 * x9)
+    result[2, 13] = numpy.sum(x104 * x122 * x123)
+    result[2, 14] = numpy.sum(x101 * x124)
+    result[3, 0] = numpy.sum(x125 * x126 * x72)
+    result[3, 1] = numpy.sum(x129 * x59 * x81)
+    result[3, 2] = numpy.sum(x130 * x62 * x81)
+    result[3, 3] = numpy.sum(x132 * x133 * x43)
+    result[3, 4] = numpy.sum(x128 * x135 * x62)
+    result[3, 5] = numpy.sum(x125 * x56 * x80)
+    result[3, 6] = numpy.sum(x137 * x139)
+    result[3, 7] = numpy.sum(x132 * x137 * x51)
+    result[3, 8] = numpy.sum(x128 * x140 * x66)
+    result[3, 9] = numpy.sum(x11 * x130 * x67)
+    result[3, 10] = numpy.sum(
+        x141 * x31 * (x0 * (3.0 * x131 + 5.0 * x96 + 2.0 * x97) + x138 * x34)
+    )
+    result[3, 11] = numpy.sum(x103 * x139 * x7)
+    result[3, 12] = numpy.sum(x10 * x132 * x56)
+    result[3, 13] = numpy.sum(x129 * x142 * x67)
+    result[3, 14] = numpy.sum(x10 * x125 * x76)
+    result[4, 0] = numpy.sum(x107 * x126 * x32 * x79)
+    result[4, 1] = numpy.sum(x109 * x143 * x86)
+    result[4, 2] = numpy.sum(x111 * x143 * x84)
+    result[4, 3] = numpy.sum(x109 * x135 * x93)
+    result[4, 4] = numpy.sum(x113 * x134 * x86)
+    result[4, 5] = numpy.sum(x117 * x134 * x84)
+    result[4, 6] = numpy.sum(x107 * x137 * x89 * x98)
+    result[4, 7] = numpy.sum(x105 * x11 * x113)
+    result[4, 8] = numpy.sum(x119 * x140 * x86)
+    result[4, 9] = numpy.sum(x122 * x144 * x77 * x89)
+    result[4, 10] = numpy.sum(x102 * x108 * x7)
+    result[4, 11] = numpy.sum(x111 * x145 * x98)
+    result[4, 12] = numpy.sum(x10 * x105 * x117)
+    result[4, 13] = numpy.sum(x122 * x145 * x86)
+    result[4, 14] = numpy.sum(x124 * x7 * x79)
+    result[5, 0] = numpy.sum(x126 * x147 * x44)
+    result[5, 1] = numpy.sum(x148 * x65 * x81)
+    result[5, 2] = numpy.sum(x151 * x68 * x81)
+    result[5, 3] = numpy.sum(x146 * x49 * x80)
+    result[5, 4] = numpy.sum(x135 * x150 * x65)
+    result[5, 5] = numpy.sum(x133 * x153 * x44)
+    result[5, 6] = numpy.sum(x11 * x148 * x57)
+    result[5, 7] = numpy.sum(x140 * x150 * x63)
+    result[5, 8] = numpy.sum(x144 * x153 * x34 * x50)
+    result[5, 9] = numpy.sum(x144 * x155)
+    result[5, 10] = numpy.sum(x10 * x147 * x71)
+    result[5, 11] = numpy.sum(x142 * x151 * x57)
+    result[5, 12] = numpy.sum(x10 * x153 * x49)
+    result[5, 13] = numpy.sum(x123 * x155 * x7)
+    result[5, 14] = numpy.sum(
+        x106 * x141 * (x0 * (5.0 * x120 + 2.0 * x121 + 3.0 * x152) + x154 * x41)
+    )
+    return result
+
+
+def ovlp3d_30(ax, da, A, bx, db, B):
+    """Cartesian 3D (fs) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((10, 1), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = -x0 * (ax * A[0] + bx * B[0]) + A[0]
+    x2 = x1**2
+    x3 = 1.5 * x0
+    x4 = 5.568327996831708
+    x5 = numpy.sqrt(x0)
+    x6 = ax * bx * x0
+    x7 = numpy.exp(-x6 * (A[0] - B[0]) ** 2)
+    x8 = numpy.exp(-x6 * (A[1] - B[1]) ** 2)
+    x9 = numpy.exp(-x6 * (A[2] - B[2]) ** 2)
+    x10 = da * db * x0 * x1 * x4 * x5 * x7 * x8 * x9
+    x11 = 0.2581988897471611
+    x12 = -x0 * (ax * A[1] + bx * B[1]) + A[1]
+    x13 = da * db * x0 * x4 * x5 * x7 * x8 * x9
+    x14 = x12 * x13
+    x15 = 0.5 * x0
+    x16 = 0.5773502691896258
+    x17 = x16 * (x15 + x2)
+    x18 = -x0 * (ax * A[2] + bx * B[2]) + A[2]
+    x19 = x13 * x18
+    x20 = x12**2
+    x21 = x15 + x20
+    x22 = x10 * x16
+    x23 = x18**2
+    x24 = x15 + x23
+
+    # 10 item(s)
+    result[0, 0] = numpy.sum(-x10 * x11 * (x2 + x3))
+    result[1, 0] = numpy.sum(-x14 * x17)
+    result[2, 0] = numpy.sum(-x17 * x19)
+    result[3, 0] = numpy.sum(-x21 * x22)
+    result[4, 0] = numpy.sum(-x10 * x12 * x18)
+    result[5, 0] = numpy.sum(-x22 * x24)
+    result[6, 0] = numpy.sum(-x11 * x14 * (x20 + x3))
+    result[7, 0] = numpy.sum(-x16 * x19 * x21)
+    result[8, 0] = numpy.sum(-x14 * x16 * x24)
+    result[9, 0] = numpy.sum(-x11 * x19 * (x23 + x3))
+    return result
+
+
+def ovlp3d_31(ax, da, A, bx, db, B):
+    """Cartesian 3D (fp) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((10, 3), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = x0 * (ax * A[0] + bx * B[0])
+    x2 = -x1
+    x3 = x2 + A[0]
+    x4 = x3**2
+    x5 = 3.0 * x0
+    x6 = x2 + B[0]
+    x7 = x3 * x6
+    x8 = x0 * (-2.0 * x1 + A[0] + B[0]) + x3 * (x0 + 2.0 * x7)
+    x9 = ax * bx * x0
+    x10 = (
+        5.568327996831708
+        * da
+        * db
+        * numpy.exp(-x9 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+    x11 = x0**1.5 * x10
+    x12 = 3.872983346207417 * x11
+    x13 = 0.01666666666666667 * x12
+    x14 = x0 * (ax * A[1] + bx * B[1])
+    x15 = -x14
+    x16 = x15 + B[1]
+    x17 = 0.06666666666666667 * x12
+    x18 = x16 * x17
+    x19 = 1.5 * x0
+    x20 = x3 * (x19 + x4)
+    x21 = x0 * (ax * A[2] + bx * B[2])
+    x22 = -x21
+    x23 = x22 + B[2]
+    x24 = x17 * x23
+    x25 = x15 + A[1]
+    x26 = x11 * x25
+    x27 = 1.732050807568877
+    x28 = 0.1666666666666667 * x27
+    x29 = x28 * x8
+    x30 = 0.5 * x0
+    x31 = x16 * x25
+    x32 = x30 + x31
+    x33 = 0.3333333333333333 * x27
+    x34 = x33 * (x30 + x4)
+    x35 = x0**1.5 * x10
+    x36 = x34 * x35
+    x37 = x22 + A[2]
+    x38 = x11 * x37
+    x39 = x23 * x37
+    x40 = x30 + x39
+    x41 = x25**2
+    x42 = x30 + x41
+    x43 = x30 + x7
+    x44 = x33 * x35
+    x45 = x43 * x44
+    x46 = x0 * (-2.0 * x14 + A[1] + B[1]) + x25 * (x0 + 2.0 * x31)
+    x47 = x28 * x46
+    x48 = x11 * x3
+    x49 = x33 * x48
+    x50 = x37**2
+    x51 = x30 + x50
+    x52 = x0 * (-2.0 * x21 + A[2] + B[2]) + x37 * (x0 + 2.0 * x39)
+    x53 = x28 * x52
+    x54 = x25 * (x19 + x41)
+    x55 = x17 * x6
+    x56 = x33 * x6
+    x57 = x37 * (x19 + x50)
+
+    # 30 item(s)
+    result[0, 0] = numpy.sum(x13 * (x0 * (2.0 * x4 + x5 + 4.0 * x7) + 2.0 * x3 * x8))
+    result[0, 1] = numpy.sum(x18 * x20)
+    result[0, 2] = numpy.sum(x20 * x24)
+    result[1, 0] = numpy.sum(x26 * x29)
+    result[1, 1] = numpy.sum(x32 * x36)
+    result[1, 2] = numpy.sum(x23 * x26 * x34)
+    result[2, 0] = numpy.sum(x29 * x38)
+    result[2, 1] = numpy.sum(x16 * x34 * x38)
+    result[2, 2] = numpy.sum(x36 * x40)
+    result[3, 0] = numpy.sum(x42 * x45)
+    result[3, 1] = numpy.sum(x47 * x48)
+    result[3, 2] = numpy.sum(x23 * x42 * x49)
+    result[4, 0] = numpy.sum(x25 * x38 * x43)
+    result[4, 1] = numpy.sum(x3 * x32 * x38)
+    result[4, 2] = numpy.sum(x26 * x3 * x40)
+    result[5, 0] = numpy.sum(x45 * x51)
+    result[5, 1] = numpy.sum(x16 * x49 * x51)
+    result[5, 2] = numpy.sum(x48 * x53)
+    result[6, 0] = numpy.sum(x54 * x55)
+    result[6, 1] = numpy.sum(x13 * (x0 * (4.0 * x31 + 2.0 * x41 + x5) + 2.0 * x25 * x46))
+    result[6, 2] = numpy.sum(x24 * x54)
+    result[7, 0] = numpy.sum(x38 * x42 * x56)
+    result[7, 1] = numpy.sum(x38 * x47)
+    result[7, 2] = numpy.sum(x40 * x42 * x44)
+    result[8, 0] = numpy.sum(x26 * x51 * x56)
+    result[8, 1] = numpy.sum(x32 * x44 * x51)
+    result[8, 2] = numpy.sum(x26 * x53)
+    result[9, 0] = numpy.sum(x55 * x57)
+    result[9, 1] = numpy.sum(x18 * x57)
+    result[9, 2] = numpy.sum(x13 * (x0 * (4.0 * x39 + x5 + 2.0 * x50) + 2.0 * x37 * x52))
+    return result
+
+
+def ovlp3d_32(ax, da, A, bx, db, B):
+    """Cartesian 3D (fd) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((10, 6), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = x0 * (ax * A[0] + bx * B[0])
+    x2 = -x1
+    x3 = x2 + B[0]
+    x4 = x3**2
+    x5 = 3.0 * x0
+    x6 = x2 + A[0]
+    x7 = x3 * x6
+    x8 = x5 + 4.0 * x7
+    x9 = x0 * (-2.0 * x1 + A[0] + B[0])
+    x10 = x0 + 2.0 * x7
+    x11 = x10 * x3
+    x12 = x11 + x9
+    x13 = 2.0 * x6
+    x14 = x0 * (2.0 * x4 + x8) + x12 * x13
+    x15 = x10 * x6
+    x16 = 2.0 * x0
+    x17 = 2.23606797749979
+    x18 = ax * bx * x0
+    x19 = (
+        5.568327996831708
+        * da
+        * db
+        * numpy.exp(-x18 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+    x20 = x0**1.5 * x19
+    x21 = 0.01666666666666667 * x20
+    x22 = x17 * x21
+    x23 = x0 * (ax * A[1] + bx * B[1])
+    x24 = -x23
+    x25 = x24 + B[1]
+    x26 = x6**2
+    x27 = x15 + x9
+    x28 = 3.872983346207417
+    x29 = x21 * x28
+    x30 = x29 * (x0 * (2.0 * x26 + x8) + x13 * x27)
+    x31 = x0 * (ax * A[2] + bx * B[2])
+    x32 = -x31
+    x33 = x32 + B[2]
+    x34 = x25**2
+    x35 = 0.5 * x0
+    x36 = x34 + x35
+    x37 = 0.06666666666666667 * x17
+    x38 = x36 * x37
+    x39 = 1.5 * x0
+    x40 = x26 + x39
+    x41 = x0**1.5 * x19
+    x42 = x41 * x6
+    x43 = x40 * x42
+    x44 = x20 * x33
+    x45 = 0.06666666666666667 * x28
+    x46 = x33**2
+    x47 = x35 + x46
+    x48 = x37 * x47
+    x49 = x24 + A[1]
+    x50 = 0.08333333333333333 * x20
+    x51 = x14 * x50
+    x52 = x25 * x49
+    x53 = x35 + x52
+    x54 = 1.732050807568877
+    x55 = 0.1666666666666667 * x41
+    x56 = x54 * x55
+    x57 = x27 * x56
+    x58 = x44 * x49
+    x59 = 0.1666666666666667 * x54
+    x60 = x27 * x59
+    x61 = x0 * (-2.0 * x23 + A[1] + B[1])
+    x62 = x0 + 2.0 * x52
+    x63 = x25 * x62
+    x64 = x61 + x63
+    x65 = x26 + x35
+    x66 = x55 * x65
+    x67 = 0.3333333333333333 * x54
+    x68 = x33 * x67
+    x69 = x41 * x65
+    x70 = 0.3333333333333333 * x47
+    x71 = x41 * x49
+    x72 = x32 + A[2]
+    x73 = x20 * x72
+    x74 = x25 * x73
+    x75 = x33 * x72
+    x76 = x35 + x75
+    x77 = 0.3333333333333333 * x36
+    x78 = x41 * x72
+    x79 = x25 * x67
+    x80 = x0 * (-2.0 * x31 + A[2] + B[2])
+    x81 = x0 + 2.0 * x75
+    x82 = x33 * x81
+    x83 = x80 + x82
+    x84 = x49**2
+    x85 = x35 + x84
+    x86 = x12 * x55
+    x87 = x49 * x62
+    x88 = x61 + x87
+    x89 = x35 + x7
+    x90 = x56 * x89
+    x91 = x41 * x89
+    x92 = x5 + 4.0 * x52
+    x93 = 2.0 * x49
+    x94 = x0 * (2.0 * x34 + x92) + x64 * x93
+    x95 = x50 * x6
+    x96 = x59 * x6
+    x97 = x59 * x73
+    x98 = x20 * x96
+    x99 = x72**2
+    x100 = x35 + x99
+    x101 = x72 * x81
+    x102 = x101 + x80
+    x103 = x5 + 4.0 * x75
+    x104 = 2.0 * x72
+    x105 = x0 * (x103 + 2.0 * x46) + x104 * x83
+    x106 = x39 + x84
+    x107 = x106 * x71
+    x108 = x35 + x4
+    x109 = x108 * x37
+    x110 = x29 * (x0 * (2.0 * x84 + x92) + x88 * x93)
+    x111 = x3 * x45
+    x112 = 0.3333333333333333 * x108
+    x113 = x3 * x41 * x67
+    x114 = x39 + x99
+    x115 = x114 * x78
+    x116 = x29 * (x0 * (x103 + 2.0 * x99) + x102 * x104)
+
+    # 60 item(s)
+    result[0, 0] = numpy.sum(-x22 * (x14 * x6 + x16 * (x11 + x15 + 2.0 * x9)))
+    result[0, 1] = numpy.sum(-x25 * x30)
+    result[0, 2] = numpy.sum(-x30 * x33)
+    result[0, 3] = numpy.sum(-x38 * x43)
+    result[0, 4] = numpy.sum(-x25 * x40 * x44 * x45 * x6)
+    result[0, 5] = numpy.sum(-x43 * x48)
+    result[1, 0] = numpy.sum(-x49 * x51)
+    result[1, 1] = numpy.sum(-x53 * x57)
+    result[1, 2] = numpy.sum(-x58 * x60)
+    result[1, 3] = numpy.sum(-x64 * x66)
+    result[1, 4] = numpy.sum(-x53 * x68 * x69)
+    result[1, 5] = numpy.sum(-x65 * x70 * x71)
+    result[2, 0] = numpy.sum(-x51 * x72)
+    result[2, 1] = numpy.sum(-x60 * x74)
+    result[2, 2] = numpy.sum(-x57 * x76)
+    result[2, 3] = numpy.sum(-x65 * x77 * x78)
+    result[2, 4] = numpy.sum(-x69 * x76 * x79)
+    result[2, 5] = numpy.sum(-x66 * x83)
+    result[3, 0] = numpy.sum(-x85 * x86)
+    result[3, 1] = numpy.sum(-x88 * x90)
+    result[3, 2] = numpy.sum(-x68 * x85 * x91)
+    result[3, 3] = numpy.sum(-x94 * x95)
+    result[3, 4] = numpy.sum(-x44 * x88 * x96)
+    result[3, 5] = numpy.sum(-x42 * x70 * x85)
+    result[4, 0] = numpy.sum(-x12 * x49 * x97)
+    result[4, 1] = numpy.sum(-x53 * x72 * x91)
+    result[4, 2] = numpy.sum(-x49 * x76 * x91)
+    result[4, 3] = numpy.sum(-x64 * x73 * x96)
+    result[4, 4] = numpy.sum(-x42 * x53 * x76)
+    result[4, 5] = numpy.sum(-x49 * x83 * x98)
+    result[5, 0] = numpy.sum(-x100 * x86)
+    result[5, 1] = numpy.sum(-x100 * x79 * x91)
+    result[5, 2] = numpy.sum(-x102 * x90)
+    result[5, 3] = numpy.sum(-x100 * x42 * x77)
+    result[5, 4] = numpy.sum(-x102 * x25 * x98)
+    result[5, 5] = numpy.sum(-x105 * x95)
+    result[6, 0] = numpy.sum(-x107 * x109)
+    result[6, 1] = numpy.sum(-x110 * x3)
+    result[6, 2] = numpy.sum(-x106 * x111 * x58)
+    result[6, 3] = numpy.sum(-x22 * (x16 * (2.0 * x61 + x63 + x87) + x49 * x94))
+    result[6, 4] = numpy.sum(-x110 * x33)
+    result[6, 5] = numpy.sum(-x107 * x48)
+    result[7, 0] = numpy.sum(-x112 * x78 * x85)
+    result[7, 1] = numpy.sum(-x3 * x88 * x97)
+    result[7, 2] = numpy.sum(-x113 * x76 * x85)
+    result[7, 3] = numpy.sum(-x50 * x72 * x94)
+    result[7, 4] = numpy.sum(-x56 * x76 * x88)
+    result[7, 5] = numpy.sum(-x55 * x83 * x85)
+    result[8, 0] = numpy.sum(-x100 * x112 * x71)
+    result[8, 1] = numpy.sum(-x100 * x113 * x53)
+    result[8, 2] = numpy.sum(-x102 * x20 * x3 * x49 * x59)
+    result[8, 3] = numpy.sum(-x100 * x55 * x64)
+    result[8, 4] = numpy.sum(-x102 * x53 * x56)
+    result[8, 5] = numpy.sum(-x105 * x49 * x50)
+    result[9, 0] = numpy.sum(-x109 * x115)
+    result[9, 1] = numpy.sum(-x111 * x114 * x74)
+    result[9, 2] = numpy.sum(-x116 * x3)
+    result[9, 3] = numpy.sum(-x115 * x38)
+    result[9, 4] = numpy.sum(-x116 * x25)
+    result[9, 5] = numpy.sum(-x22 * (x105 * x72 + x16 * (x101 + 2.0 * x80 + x82)))
+    return result
+
+
+def ovlp3d_33(ax, da, A, bx, db, B):
+    """Cartesian 3D (ff) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((10, 10), dtype=float)
+
+    x0 = (ax + bx) ** (-1.0)
+    x1 = x0 * (ax * A[0] + bx * B[0])
+    x2 = -x1
+    x3 = x2 + B[0]
+    x4 = x0 * (-2.0 * x1 + A[0] + B[0])
+    x5 = x2 + A[0]
+    x6 = x3 * x5
+    x7 = x0 + 2.0 * x6
+    x8 = x3 * x7
+    x9 = x4 + x8
+    x10 = x3 * x9
+    x11 = x3**2
+    x12 = 3.0 * x0
+    x13 = x12 + 4.0 * x6
+    x14 = x0 * (2.0 * x11 + x13)
+    x15 = x5 * x9
+    x16 = x14 + 2.0 * x15
+    x17 = x5 * x7
+    x18 = 2.0 * x0
+    x19 = x18 * (x17 + 2.0 * x4 + x8)
+    x20 = x16 * x3 + x19
+    x21 = 2.0 * x5
+    x22 = ax * bx * x0
+    x23 = (
+        5.568327996831708
+        * da
+        * db
+        * numpy.exp(-x22 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
+    )
+    x24 = x0**1.5 * x23
+    x25 = 0.008333333333333333 * x24
+    x26 = x0 * (ax * A[1] + bx * B[1])
+    x27 = -x26
+    x28 = x27 + B[1]
+    x29 = 2.23606797749979
+    x30 = 0.01666666666666667 * x29
+    x31 = x24 * x30
+    x32 = x31 * (x16 * x5 + x19)
+    x33 = x0 * (ax * A[2] + bx * B[2])
+    x34 = -x33
+    x35 = x34 + B[2]
+    x36 = x28**2
+    x37 = 0.5 * x0
+    x38 = x36 + x37
+    x39 = x0**1.5 * x23
+    x40 = x38 * x39
+    x41 = x5**2
+    x42 = x17 + x4
+    x43 = x0 * (x13 + 2.0 * x41) + x21 * x42
+    x44 = x30 * x43
+    x45 = 0.06454972243679028
+    x46 = x24 * x45
+    x47 = x35**2
+    x48 = x37 + x47
+    x49 = x39 * x48
+    x50 = 1.5 * x0
+    x51 = 0.06666666666666667 * x5
+    x52 = x51 * (x41 + x50)
+    x53 = x36 + x50
+    x54 = x28 * x39
+    x55 = x53 * x54
+    x56 = x29 * x52
+    x57 = x47 + x50
+    x58 = x35 * x39
+    x59 = x57 * x58
+    x60 = x27 + A[1]
+    x61 = x20 * x31
+    x62 = 0.08333333333333333 * x16
+    x63 = x28 * x60
+    x64 = x39 * (x37 + x63)
+    x65 = x24 * x62
+    x66 = x35 * x60
+    x67 = x0 * (-2.0 * x26 + A[1] + B[1])
+    x68 = x0 + 2.0 * x63
+    x69 = x28 * x68
+    x70 = x67 + x69
+    x71 = 0.08333333333333333 * x39
+    x72 = x42 * x71
+    x73 = 1.732050807568877
+    x74 = 0.1666666666666667 * x42
+    x75 = x73 * x74
+    x76 = x49 * x60
+    x77 = x12 + 4.0 * x63
+    x78 = x0 * (2.0 * x36 + x77)
+    x79 = 2.0 * x70
+    x80 = x28 * x79 + x78
+    x81 = x37 + x41
+    x82 = x39 * x81
+    x83 = x30 * x82
+    x84 = 0.1666666666666667 * x82
+    x85 = 0.3333333333333333 * x81
+    x86 = x29 * x57
+    x87 = 0.06666666666666667 * x82
+    x88 = x34 + A[2]
+    x89 = x28 * x88
+    x90 = x35 * x88
+    x91 = x37 + x90
+    x92 = x39 * x91
+    x93 = x40 * x88
+    x94 = x0 * (-2.0 * x33 + A[2] + B[2])
+    x95 = x0 + 2.0 * x90
+    x96 = x35 * x95
+    x97 = x94 + x96
+    x98 = x29 * x53
+    x99 = x12 + 4.0 * x90
+    x100 = x0 * (2.0 * x47 + x99)
+    x101 = 2.0 * x97
+    x102 = x100 + x101 * x35
+    x103 = x60**2
+    x104 = x103 + x37
+    x105 = x104 * x39
+    x106 = 2.0 * x10 + x14
+    x107 = x106 * x30
+    x108 = x60 * x68
+    x109 = x108 + x67
+    x110 = x71 * x9
+    x111 = 0.1666666666666667 * x9
+    x112 = x105 * x35
+    x113 = x60 * x79 + x78
+    x114 = x37 + x6
+    x115 = x114 * x71
+    x116 = x109 * x73
+    x117 = 0.1666666666666667 * x114
+    x118 = 0.3333333333333333 * x114
+    x119 = x18 * (x108 + 2.0 * x67 + x69)
+    x120 = x113 * x28 + x119
+    x121 = x31 * x5
+    x122 = x24 * x5
+    x123 = 0.08333333333333333 * x113
+    x124 = 0.1666666666666667 * x5
+    x125 = x111 * x73
+    x126 = x70 * x73
+    x127 = x39 * x88
+    x128 = x73 * x97
+    x129 = x39 * x60
+    x130 = x122 * x45
+    x131 = x88**2
+    x132 = x131 + x37
+    x133 = x132 * x39
+    x134 = x133 * x28
+    x135 = x88 * x95
+    x136 = x135 + x94
+    x137 = x136 * x73
+    x138 = x100 + x101 * x88
+    x139 = 0.08333333333333333 * x138
+    x140 = x18 * (x135 + 2.0 * x94 + x96)
+    x141 = x138 * x35 + x140
+    x142 = 0.06666666666666667 * x103 + 0.06666666666666667 * x50
+    x143 = x3 * (x11 + x50)
+    x144 = 2.0 * x60
+    x145 = x0 * (2.0 * x103 + x77) + x109 * x144
+    x146 = x145 * x30
+    x147 = x11 + x37
+    x148 = x147 * x39
+    x149 = x142 * x29
+    x150 = x31 * (x113 * x60 + x119)
+    x151 = x24 * x3
+    x152 = x151 * x45
+    x153 = 0.06666666666666667 * x143 * x29
+    x154 = 0.1666666666666667 * x148
+    x155 = 0.3333333333333333 * x147
+    x156 = 0.1666666666666667 * x3
+    x157 = 0.06666666666666667 * x131 + 0.06666666666666667 * x50
+    x158 = x157 * x29
+    x159 = 2.0 * x88
+    x160 = x0 * (2.0 * x131 + x99) + x136 * x159
+    x161 = x160 * x30
+    x162 = x31 * (x138 * x88 + x140)
+
+    # 100 item(s)
+    result[0, 0] = numpy.sum(x25 * (x0 * (4.0 * x10 + 5.0 * x14 + 6.0 * x15) + x20 * x21))
+    result[0, 1] = numpy.sum(x28 * x32)
+    result[0, 2] = numpy.sum(x32 * x35)
+    result[0, 3] = numpy.sum(x40 * x44)
+    result[0, 4] = numpy.sum(x28 * x35 * x43 * x46)
+    result[0, 5] = numpy.sum(x44 * x49)
+    result[0, 6] = numpy.sum(x52 * x55)
+    result[0, 7] = numpy.sum(x35 * x40 * x56)
+    result[0, 8] = numpy.sum(x28 * x49 * x56)
+    result[0, 9] = numpy.sum(x52 * x59)
+    result[1, 0] = numpy.sum(x60 * x61)
+    result[1, 1] = numpy.sum(x62 * x64)
+    result[1, 2] = numpy.sum(x65 * x66)
+    result[1, 3] = numpy.sum(x70 * x72)
+    result[1, 4] = numpy.sum(x35 * x64 * x75)
+    result[1, 5] = numpy.sum(x74 * x76)
+    result[1, 6] = numpy.sum(x80 * x83)
+    result[1, 7] = numpy.sum(x35 * x70 * x84)
+    result[1, 8] = numpy.sum(x48 * x64 * x85)
+    result[1, 9] = numpy.sum(x66 * x86 * x87)
+    result[2, 0] = numpy.sum(x61 * x88)
+    result[2, 1] = numpy.sum(x65 * x89)
+    result[2, 2] = numpy.sum(x62 * x92)
+    result[2, 3] = numpy.sum(x74 * x93)
+    result[2, 4] = numpy.sum(x28 * x75 * x92)
+    result[2, 5] = numpy.sum(x72 * x97)
+    result[2, 6] = numpy.sum(x87 * x89 * x98)
+    result[2, 7] = numpy.sum(x38 * x85 * x92)
+    result[2, 8] = numpy.sum(x28 * x84 * x97)
+    result[2, 9] = numpy.sum(x102 * x83)
+    result[3, 0] = numpy.sum(x105 * x107)
+    result[3, 1] = numpy.sum(x109 * x110)
+    result[3, 2] = numpy.sum(x111 * x112)
+    result[3, 3] = numpy.sum(x113 * x115)
+    result[3, 4] = numpy.sum(x116 * x117 * x58)
+    result[3, 5] = numpy.sum(x104 * x118 * x49)
+    result[3, 6] = numpy.sum(x120 * x121)
+    result[3, 7] = numpy.sum(x122 * x123 * x35)
+    result[3, 8] = numpy.sum(x109 * x124 * x49)
+    result[3, 9] = numpy.sum(x112 * x51 * x86)
+    result[4, 0] = numpy.sum(x106 * x46 * x60 * x88)
+    result[4, 1] = numpy.sum(x125 * x64 * x88)
+    result[4, 2] = numpy.sum(x125 * x60 * x92)
+    result[4, 3] = numpy.sum(x117 * x126 * x127)
+    result[4, 4] = numpy.sum(x114 * x64 * x91)
+    result[4, 5] = numpy.sum(x117 * x128 * x129)
+    result[4, 6] = numpy.sum(x130 * x80 * x88)
+    result[4, 7] = numpy.sum(x124 * x126 * x92)
+    result[4, 8] = numpy.sum(x124 * x128 * x64)
+    result[4, 9] = numpy.sum(x102 * x130 * x60)
+    result[5, 0] = numpy.sum(x107 * x133)
+    result[5, 1] = numpy.sum(x111 * x134)
+    result[5, 2] = numpy.sum(x110 * x136)
+    result[5, 3] = numpy.sum(x118 * x132 * x40)
+    result[5, 4] = numpy.sum(x117 * x137 * x54)
+    result[5, 5] = numpy.sum(x115 * x138)
+    result[5, 6] = numpy.sum(x134 * x51 * x98)
+    result[5, 7] = numpy.sum(x124 * x136 * x40)
+    result[5, 8] = numpy.sum(x122 * x139 * x28)
+    result[5, 9] = numpy.sum(x121 * x141)
+    result[6, 0] = numpy.sum(x129 * x142 * x143)
+    result[6, 1] = numpy.sum(x146 * x148)
+    result[6, 2] = numpy.sum(x148 * x149 * x66)
+    result[6, 3] = numpy.sum(x150 * x3)
+    result[6, 4] = numpy.sum(x145 * x152 * x35)
+    result[6, 5] = numpy.sum(x149 * x3 * x76)
+    result[6, 6] = numpy.sum(
+        x25 * (x0 * (4.0 * x28 * x70 + 6.0 * x60 * x70 + 5.0 * x78) + x120 * x144)
+    )
+    result[6, 7] = numpy.sum(x150 * x35)
+    result[6, 8] = numpy.sum(x146 * x49)
+    result[6, 9] = numpy.sum(x142 * x59 * x60)
+    result[7, 0] = numpy.sum(x105 * x153 * x88)
+    result[7, 1] = numpy.sum(x109 * x154 * x88)
+    result[7, 2] = numpy.sum(x104 * x155 * x92)
+    result[7, 3] = numpy.sum(x123 * x151 * x88)
+    result[7, 4] = numpy.sum(x116 * x156 * x92)
+    result[7, 5] = numpy.sum(x105 * x156 * x97)
+    result[7, 6] = numpy.sum(x120 * x31 * x88)
+    result[7, 7] = numpy.sum(x113 * x71 * x91)
+    result[7, 8] = numpy.sum(x109 * x71 * x97)
+    result[7, 9] = numpy.sum(x102 * x105 * x30)
+    result[8, 0] = numpy.sum(x133 * x153 * x60)
+    result[8, 1] = numpy.sum(x132 * x155 * x64)
+    result[8, 2] = numpy.sum(x136 * x154 * x60)
+    result[8, 3] = numpy.sum(x133 * x156 * x70)
+    result[8, 4] = numpy.sum(x137 * x156 * x64)
+    result[8, 5] = numpy.sum(x139 * x151 * x60)
+    result[8, 6] = numpy.sum(x133 * x30 * x80)
+    result[8, 7] = numpy.sum(x136 * x70 * x71)
+    result[8, 8] = numpy.sum(x139 * x64)
+    result[8, 9] = numpy.sum(x141 * x31 * x60)
+    result[9, 0] = numpy.sum(x127 * x143 * x157)
+    result[9, 1] = numpy.sum(x148 * x158 * x89)
+    result[9, 2] = numpy.sum(x148 * x161)
+    result[9, 3] = numpy.sum(x158 * x3 * x93)
+    result[9, 4] = numpy.sum(x152 * x160 * x28)
+    result[9, 5] = numpy.sum(x162 * x3)
+    result[9, 6] = numpy.sum(x157 * x55 * x88)
+    result[9, 7] = numpy.sum(x161 * x40)
+    result[9, 8] = numpy.sum(x162 * x28)
+    result[9, 9] = numpy.sum(
+        x25 * (x0 * (5.0 * x100 + 4.0 * x35 * x97 + 6.0 * x88 * x97) + x141 * x159)
+    )
+    return result
+
+
+def ovlp3d_34(ax, da, A, bx, db, B):
+    """Cartesian 3D (fg) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((10, 15), dtype=float)
+
+    x0 = 0.5 / (ax + bx)
+    x1 = (ax + bx) ** (-1.0)
+    x2 = -x1 * (ax * A[0] + bx * B[0])
+    x3 = -x2 - A[0]
+    x4 = -x2 - B[0]
+    x5 = ax * bx * x1
+    x6 = numpy.exp(-x5 * (A[0] - B[0]) ** 2)
+    x7 = 1.772453850905516 * numpy.sqrt(x1)
+    x8 = x6 * x7
+    x9 = x4**2 * x8
+    x10 = x0 * x8
+    x11 = 3.0 * x10
+    x12 = x3 * x8
+    x13 = x12 * x4
+    x14 = x11 + 2.0 * x13
+    x15 = x0 * (x14 + x9)
+    x16 = x4 * x8
+    x17 = x0 * (x12 + x16)
+    x18 = x10 + x13
+    x19 = x18 * x4
+    x20 = x17 + x19
+    x21 = x20 * x3
+    x22 = x15 + x21
+    x23 = x22 * x3
+    x24 = x22 * x4
+    x25 = x18 * x3
+    x26 = 2.0 * x0 * (2.0 * x17 + x19 + x25)
+    x27 = x20 * x4
+    x28 = x0 * (5.0 * x15 + 3.0 * x21 + 2.0 * x27)
+    x29 = x24 + x26
+    x30 = x28 + x29 * x3
+    x31 = da * db
+    x32 = 0.009523809523809524 * x31
+    x33 = 2.645751311064591 * x32
+    x34 = numpy.exp(-x5 * (A[1] - B[1]) ** 2)
+    x35 = numpy.exp(-x5 * (A[2] - B[2]) ** 2)
+    x36 = 3.141592653589793 * x1 * x35
+    x37 = x34 * x36
+    x38 = -x1 * (ax * A[1] + bx * B[1])
+    x39 = -x38 - B[1]
+    x40 = 0.06666666666666667 * x31
+    x41 = x39 * x40
+    x42 = x30 * x37
+    x43 = -x1 * (ax * A[2] + bx * B[2])
+    x44 = -x43 - B[2]
+    x45 = x40 * x44
+    x46 = x23 + x26
+    x47 = x35 * x7
+    x48 = 3.872983346207417
+    x49 = 0.02222222222222222 * x48
+    x50 = x34 * x7
+    x51 = x39**2 * x50
+    x52 = x0 * x50
+    x53 = x51 + x52
+    x54 = x31 * x53
+    x55 = x49 * x54
+    x56 = 2.23606797749979
+    x57 = x40 * x56
+    x58 = x44 * x57
+    x59 = x37 * x58
+    x60 = x44**2 * x47
+    x61 = x0 * x47
+    x62 = x60 + x61
+    x63 = x31 * x62
+    x64 = x49 * x63
+    x65 = 2.0 * x52
+    x66 = x39 * (x53 + x65)
+    x67 = x3**2 * x8
+    x68 = x17 + x25
+    x69 = x0 * (x14 + x67) + x3 * x68
+    x70 = x40 * x69
+    x71 = x44 * x47
+    x72 = x57 * x71
+    x73 = x39 * x50
+    x74 = 0.06666666666666667 * x56 * x63
+    x75 = 2.0 * x61
+    x76 = x44 * (x62 + x75)
+    x77 = 3.0 * x52
+    x78 = x0 * (3.0 * x51 + x77) + x39 * x66
+    x79 = x10 + x67
+    x80 = 2.0 * x0
+    x81 = x12 * x80 + x3 * x79
+    x82 = x33 * x81
+    x83 = x40 * x81
+    x84 = 3.0 * x61
+    x85 = x0 * (3.0 * x60 + x84) + x44 * x76
+    x86 = -x38 - A[1]
+    x87 = 5.916079783099616 * x32
+    x88 = x86 * x87
+    x89 = x37 * (x28 + x29 * x4)
+    x90 = x50 * x86
+    x91 = x39 * x90
+    x92 = x52 + x91
+    x93 = x47 * x57
+    x94 = x0 * (x73 + x90)
+    x95 = x39 * x92
+    x96 = x94 + x95
+    x97 = 1.732050807568877
+    x98 = x96 * x97
+    x99 = 0.1111111111111111 * x31
+    x100 = x22 * x99
+    x101 = 0.3333333333333333 * x31
+    x102 = x101 * x92
+    x103 = 0.1111111111111111 * x97
+    x104 = x103 * x22
+    x105 = x77 + 2.0 * x91
+    x106 = x0 * (x105 + x51)
+    x107 = x39 * x96
+    x108 = x106 + x107
+    x109 = x101 * x68
+    x110 = x57 * x68
+    x111 = x0 * (x66 + 3.0 * x94 + 3.0 * x95) + x108 * x39
+    x112 = x79 * x87
+    x113 = x57 * x79
+    x114 = 0.1111111111111111 * x79
+    x115 = -x43 - A[2]
+    x116 = x115 * x87
+    x117 = x115 * x37
+    x118 = x39 * x57
+    x119 = x115 * x47
+    x120 = x119 * x44
+    x121 = x120 + x61
+    x122 = x50 * x57
+    x123 = x101 * x73
+    x124 = x0 * (x119 + x71)
+    x125 = x121 * x44
+    x126 = x124 + x125
+    x127 = x126 * x97
+    x128 = 2.0 * x120 + x84
+    x129 = x0 * (x128 + x60)
+    x130 = x126 * x44
+    x131 = x129 + x130
+    x132 = x0 * (3.0 * x124 + 3.0 * x125 + x76) + x131 * x44
+    x133 = x50 * x86**2
+    x134 = x133 + x52
+    x135 = x10 + x9
+    x136 = x135 * x4 + x16 * x80
+    x137 = x15 + x27
+    x138 = x0 * (x136 + 3.0 * x17 + 3.0 * x19) + x137 * x4
+    x139 = x138 * x87
+    x140 = x86 * x92
+    x141 = x140 + x94
+    x142 = x86 * x96
+    x143 = x106 + x142
+    x144 = x20 * x97
+    x145 = x144 * x99
+    x146 = x101 * x20
+    x147 = 0.1111111111111111 * x134
+    x148 = 2.0 * x0 * (x140 + 2.0 * x94 + x95)
+    x149 = x143 * x39
+    x150 = x148 + x149
+    x151 = x18 * x57
+    x152 = x101 * x18
+    x153 = x3 * x87
+    x154 = x0 * (5.0 * x106 + 2.0 * x107 + 3.0 * x142)
+    x155 = x36 * x6
+    x156 = x155 * (x150 * x39 + x154)
+    x157 = x155 * x3
+    x158 = x103 * x12
+    x159 = x12 * x57
+    x160 = x12 * x87
+    x161 = 10.2469507659596 * x32
+    x162 = x161 * x86
+    x163 = x40 * x48
+    x164 = x137 * x163
+    x165 = x163 * x18
+    x166 = x12 * x163
+    x167 = x101 * x126
+    x168 = 3.141592653589793 * x1 * x34 * x6
+    x169 = x168 * x3
+    x170 = x115**2 * x47
+    x171 = x170 + x61
+    x172 = x171 * x57
+    x173 = x115 * x121
+    x174 = x124 + x173
+    x175 = 0.1111111111111111 * x171
+    x176 = x115 * x126
+    x177 = x129 + x176
+    x178 = 2.0 * x0 * (2.0 * x124 + x125 + x173)
+    x179 = x177 * x44
+    x180 = x178 + x179
+    x181 = x0 * (5.0 * x129 + 2.0 * x130 + 3.0 * x176)
+    x182 = x168 * (x180 * x44 + x181)
+    x183 = x0 * (x11 + 3.0 * x9) + x136 * x4
+    x184 = x86 * (x134 + x65)
+    x185 = x184 * x33
+    x186 = x0 * (x105 + x133) + x141 * x86
+    x187 = x186 * x40
+    x188 = x184 * x40
+    x189 = x143 * x86
+    x190 = x148 + x189
+    x191 = x135 * x31
+    x192 = x191 * x49
+    x193 = x150 * x86 + x154
+    x194 = x155 * x193
+    x195 = x4 * x40
+    x196 = x155 * x4
+    x197 = x183 * x87
+    x198 = x136 * x57
+    x199 = x103 * x191
+    x200 = x101 * x135
+    x201 = x101 * x16
+    x202 = x16 * x57
+    x203 = x57 * x8
+    x204 = x8 * x99
+    x205 = x8 * x87
+    x206 = x168 * x4
+    x207 = x115 * (x171 + x75)
+    x208 = x207 * x33
+    x209 = x207 * x40
+    x210 = x0 * (x128 + x170) + x115 * x174
+    x211 = x210 * x40
+    x212 = x115 * x177
+    x213 = x178 + x212
+    x214 = x115 * x180 + x181
+    x215 = x168 * x214
+
+    # 150 item(s)
+    result[0, 0] = numpy.sum(x33 * x37 * (3.0 * x0 * (x23 + x24 + 2.0 * x26) + x30 * x4))
+    result[0, 1] = numpy.sum(x41 * x42)
+    result[0, 2] = numpy.sum(x42 * x45)
+    result[0, 3] = numpy.sum(x46 * x47 * x55)
+    result[0, 4] = numpy.sum(x39 * x46 * x59)
+    result[0, 5] = numpy.sum(x46 * x50 * x64)
+    result[0, 6] = numpy.sum(x47 * x66 * x70)
+    result[0, 7] = numpy.sum(x53 * x69 * x72)
+    result[0, 8] = numpy.sum(x69 * x73 * x74)
+    result[0, 9] = numpy.sum(x50 * x70 * x76)
+    result[0, 10] = numpy.sum(x47 * x78 * x82)
+    result[0, 11] = numpy.sum(x66 * x71 * x83)
+    result[0, 12] = numpy.sum(x53 * x64 * x81)
+    result[0, 13] = numpy.sum(x73 * x76 * x83)
+    result[0, 14] = numpy.sum(x50 * x82 * x85)
+    result[1, 0] = numpy.sum(x88 * x89)
+    result[1, 1] = numpy.sum(x29 * x92 * x93)
+    result[1, 2] = numpy.sum(x29 * x59 * x86)
+    result[1, 3] = numpy.sum(x100 * x47 * x98)
+    result[1, 4] = numpy.sum(x102 * x22 * x71)
+    result[1, 5] = numpy.sum(x104 * x63 * x90)
+    result[1, 6] = numpy.sum(x108 * x68 * x93)
+    result[1, 7] = numpy.sum(x109 * x71 * x96)
+    result[1, 8] = numpy.sum(x109 * x62 * x92)
+    result[1, 9] = numpy.sum(x110 * x76 * x90)
+    result[1, 10] = numpy.sum(x111 * x112 * x47)
+    result[1, 11] = numpy.sum(x108 * x113 * x71)
+    result[1, 12] = numpy.sum(x114 * x63 * x98)
+    result[1, 13] = numpy.sum(x113 * x76 * x92)
+    result[1, 14] = numpy.sum(x112 * x85 * x90)
+    result[2, 0] = numpy.sum(x116 * x89)
+    result[2, 1] = numpy.sum(x117 * x118 * x29)
+    result[2, 2] = numpy.sum(x121 * x122 * x29)
+    result[2, 3] = numpy.sum(x104 * x119 * x54)
+    result[2, 4] = numpy.sum(x121 * x123 * x22)
+    result[2, 5] = numpy.sum(x100 * x127 * x50)
+    result[2, 6] = numpy.sum(x110 * x119 * x66)
+    result[2, 7] = numpy.sum(x109 * x121 * x53)
+    result[2, 8] = numpy.sum(x109 * x126 * x73)
+    result[2, 9] = numpy.sum(x122 * x131 * x68)
+    result[2, 10] = numpy.sum(x112 * x119 * x78)
+    result[2, 11] = numpy.sum(x113 * x121 * x66)
+    result[2, 12] = numpy.sum(x114 * x127 * x54)
+    result[2, 13] = numpy.sum(x113 * x131 * x73)
+    result[2, 14] = numpy.sum(x112 * x132 * x50)
+    result[3, 0] = numpy.sum(x134 * x139 * x47)
+    result[3, 1] = numpy.sum(x137 * x141 * x93)
+    result[3, 2] = numpy.sum(x134 * x137 * x72)
+    result[3, 3] = numpy.sum(x143 * x145 * x47)
+    result[3, 4] = numpy.sum(x141 * x146 * x71)
+    result[3, 5] = numpy.sum(x144 * x147 * x63)
+    result[3, 6] = numpy.sum(x150 * x151 * x47)
+    result[3, 7] = numpy.sum(x143 * x152 * x71)
+    result[3, 8] = numpy.sum(x141 * x152 * x62)
+    result[3, 9] = numpy.sum(x134 * x151 * x76)
+    result[3, 10] = numpy.sum(x153 * x156)
+    result[3, 11] = numpy.sum(x150 * x157 * x58)
+    result[3, 12] = numpy.sum(x143 * x158 * x63)
+    result[3, 13] = numpy.sum(x141 * x159 * x76)
+    result[3, 14] = numpy.sum(x134 * x160 * x85)
+    result[4, 0] = numpy.sum(x117 * x138 * x162)
+    result[4, 1] = numpy.sum(x119 * x164 * x92)
+    result[4, 2] = numpy.sum(x121 * x164 * x90)
+    result[4, 3] = numpy.sum(x119 * x146 * x96)
+    result[4, 4] = numpy.sum(x102 * x121 * x144)
+    result[4, 5] = numpy.sum(x126 * x146 * x90)
+    result[4, 6] = numpy.sum(x108 * x119 * x165)
+    result[4, 7] = numpy.sum(x121 * x152 * x98)
+    result[4, 8] = numpy.sum(x127 * x152 * x92)
+    result[4, 9] = numpy.sum(x131 * x165 * x90)
+    result[4, 10] = numpy.sum(x111 * x115 * x157 * x161)
+    result[4, 11] = numpy.sum(x108 * x121 * x166)
+    result[4, 12] = numpy.sum(x12 * x167 * x96)
+    result[4, 13] = numpy.sum(x131 * x166 * x92)
+    result[4, 14] = numpy.sum(x132 * x162 * x169)
+    result[5, 0] = numpy.sum(x139 * x171 * x50)
+    result[5, 1] = numpy.sum(x137 * x172 * x73)
+    result[5, 2] = numpy.sum(x122 * x137 * x174)
+    result[5, 3] = numpy.sum(x144 * x175 * x54)
+    result[5, 4] = numpy.sum(x123 * x174 * x20)
+    result[5, 5] = numpy.sum(x145 * x177 * x50)
+    result[5, 6] = numpy.sum(x151 * x171 * x66)
+    result[5, 7] = numpy.sum(x152 * x174 * x53)
+    result[5, 8] = numpy.sum(x152 * x177 * x73)
+    result[5, 9] = numpy.sum(x151 * x180 * x50)
+    result[5, 10] = numpy.sum(x160 * x171 * x78)
+    result[5, 11] = numpy.sum(x159 * x174 * x66)
+    result[5, 12] = numpy.sum(x158 * x177 * x54)
+    result[5, 13] = numpy.sum(x118 * x169 * x180)
+    result[5, 14] = numpy.sum(x153 * x182)
+    result[6, 0] = numpy.sum(x183 * x185 * x47)
+    result[6, 1] = numpy.sum(x136 * x187 * x47)
+    result[6, 2] = numpy.sum(x136 * x188 * x71)
+    result[6, 3] = numpy.sum(x190 * x192 * x47)
+    result[6, 4] = numpy.sum(x135 * x186 * x72)
+    result[6, 5] = numpy.sum(x135 * x184 * x64)
+    result[6, 6] = numpy.sum(x194 * x195)
+    result[6, 7] = numpy.sum(x190 * x196 * x58)
+    result[6, 8] = numpy.sum(x16 * x186 * x74)
+    result[6, 9] = numpy.sum(x16 * x188 * x76)
+    result[6, 10] = numpy.sum(
+        x155 * x33 * (3.0 * x0 * (2.0 * x148 + x149 + x189) + x193 * x39)
+    )
+    result[6, 11] = numpy.sum(x194 * x45)
+    result[6, 12] = numpy.sum(x190 * x64 * x8)
+    result[6, 13] = numpy.sum(x187 * x76 * x8)
+    result[6, 14] = numpy.sum(x185 * x8 * x85)
+    result[7, 0] = numpy.sum(x119 * x134 * x197)
+    result[7, 1] = numpy.sum(x119 * x141 * x198)
+    result[7, 2] = numpy.sum(x121 * x134 * x198)
+    result[7, 3] = numpy.sum(x119 * x143 * x199)
+    result[7, 4] = numpy.sum(x121 * x141 * x200)
+    result[7, 5] = numpy.sum(x127 * x147 * x191)
+    result[7, 6] = numpy.sum(x115 * x150 * x196 * x57)
+    result[7, 7] = numpy.sum(x121 * x143 * x201)
+    result[7, 8] = numpy.sum(x141 * x16 * x167)
+    result[7, 9] = numpy.sum(x131 * x134 * x202)
+    result[7, 10] = numpy.sum(x116 * x156)
+    result[7, 11] = numpy.sum(x121 * x150 * x203)
+    result[7, 12] = numpy.sum(x127 * x143 * x204)
+    result[7, 13] = numpy.sum(x131 * x141 * x203)
+    result[7, 14] = numpy.sum(x132 * x134 * x205)
+    result[8, 0] = numpy.sum(x171 * x197 * x90)
+    result[8, 1] = numpy.sum(x171 * x198 * x92)
+    result[8, 2] = numpy.sum(x174 * x198 * x90)
+    result[8, 3] = numpy.sum(x175 * x191 * x98)
+    result[8, 4] = numpy.sum(x174 * x200 * x92)
+    result[8, 5] = numpy.sum(x177 * x199 * x90)
+    result[8, 6] = numpy.sum(x108 * x16 * x172)
+    result[8, 7] = numpy.sum(x174 * x201 * x96)
+    result[8, 8] = numpy.sum(x102 * x16 * x177)
+    result[8, 9] = numpy.sum(x180 * x206 * x57 * x86)
+    result[8, 10] = numpy.sum(x111 * x171 * x205)
+    result[8, 11] = numpy.sum(x108 * x174 * x203)
+    result[8, 12] = numpy.sum(x177 * x204 * x98)
+    result[8, 13] = numpy.sum(x180 * x203 * x92)
+    result[8, 14] = numpy.sum(x182 * x88)
+    result[9, 0] = numpy.sum(x183 * x208 * x50)
+    result[9, 1] = numpy.sum(x136 * x209 * x73)
+    result[9, 2] = numpy.sum(x136 * x211 * x50)
+    result[9, 3] = numpy.sum(x135 * x207 * x55)
+    result[9, 4] = numpy.sum(x135 * x210 * x57 * x73)
+    result[9, 5] = numpy.sum(x192 * x213 * x50)
+    result[9, 6] = numpy.sum(x16 * x209 * x66)
+    result[9, 7] = numpy.sum(x202 * x210 * x53)
+    result[9, 8] = numpy.sum(x118 * x206 * x213)
+    result[9, 9] = numpy.sum(x195 * x215)
+    result[9, 10] = numpy.sum(x208 * x78 * x8)
+    result[9, 11] = numpy.sum(x211 * x66 * x8)
+    result[9, 12] = numpy.sum(x213 * x55 * x8)
+    result[9, 13] = numpy.sum(x215 * x41)
+    result[9, 14] = numpy.sum(
+        x168 * x33 * (3.0 * x0 * (2.0 * x178 + x179 + x212) + x214 * x44)
+    )
+    return result
+
+
+def ovlp3d_40(ax, da, A, bx, db, B):
+    """Cartesian 3D (gs) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((15, 1), dtype=float)
+
+    x0 = 0.5 / (ax + bx)
+    x1 = (ax + bx) ** (-1.0)
+    x2 = x1 * (ax * A[0] + bx * B[0]) - A[0]
+    x3 = ax * bx * x1
+    x4 = numpy.exp(-x3 * (A[0] - B[0]) ** 2)
+    x5 = 1.772453850905516 * numpy.sqrt(x1)
+    x6 = x4 * x5
+    x7 = x2**2 * x6
+    x8 = x0 * x6
+    x9 = x7 + x8
+    x10 = x2 * (2.0 * x8 + x9)
+    x11 = numpy.exp(-x3 * (A[1] - B[1]) ** 2)
+    x12 = da * db
+    x13 = numpy.exp(-x3 * (A[2] - B[2]) ** 2)
+    x14 = 3.141592653589793 * x1 * x13
+    x15 = x12 * x14
+    x16 = x11 * x15
+    x17 = 0.09759000729485332
+    x18 = x1 * (ax * A[1] + bx * B[1]) - A[1]
+    x19 = 0.2581988897471611
+    x20 = x18 * x19
+    x21 = x10 * x16
+    x22 = x1 * (ax * A[2] + bx * B[2]) - A[2]
+    x23 = x19 * x22
+    x24 = x11 * x5
+    x25 = x18**2 * x24
+    x26 = x0 * x24
+    x27 = x25 + x26
+    x28 = x13 * x5
+    x29 = 0.3333333333333333 * x12
+    x30 = x29 * x9
+    x31 = 1.732050807568877
+    x32 = x18 * x31
+    x33 = x14 * x22
+    x34 = x22**2 * x28
+    x35 = x0 * x28
+    x36 = x34 + x35
+    x37 = x2 * x4
+    x38 = x19 * x37
+    x39 = x18 * (2.0 * x26 + x27)
+    x40 = x15 * x39
+    x41 = x27 * x29
+    x42 = 3.141592653589793 * x1 * x11
+    x43 = x22 * (2.0 * x35 + x36)
+    x44 = x12 * x42
+    x45 = x43 * x44
+    x46 = x17 * x4
+
+    # 15 item(s)
+    result[0, 0] = numpy.sum(x16 * x17 * (3.0 * x0 * (x7 + x8) + x10 * x2))
+    result[1, 0] = numpy.sum(x20 * x21)
+    result[2, 0] = numpy.sum(x21 * x23)
+    result[3, 0] = numpy.sum(x27 * x28 * x30)
+    result[4, 0] = numpy.sum(x11 * x30 * x32 * x33)
+    result[5, 0] = numpy.sum(x24 * x30 * x36)
+    result[6, 0] = numpy.sum(x38 * x40)
+    result[7, 0] = numpy.sum(x31 * x33 * x37 * x41)
+    result[8, 0] = numpy.sum(x29 * x32 * x36 * x37 * x42)
+    result[9, 0] = numpy.sum(x38 * x45)
+    result[10, 0] = numpy.sum(x15 * x46 * (3.0 * x0 * (x25 + x26) + x18 * x39))
+    result[11, 0] = numpy.sum(x23 * x4 * x40)
+    result[12, 0] = numpy.sum(x36 * x41 * x6)
+    result[13, 0] = numpy.sum(x20 * x4 * x45)
+    result[14, 0] = numpy.sum(x44 * x46 * (3.0 * x0 * (x34 + x35) + x22 * x43))
+    return result
+
+
+def ovlp3d_41(ax, da, A, bx, db, B):
+    """Cartesian 3D (gp) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((15, 3), dtype=float)
+
+    x0 = 0.5 / (ax + bx)
+    x1 = (ax + bx) ** (-1.0)
+    x2 = -x1 * (ax * A[0] + bx * B[0])
+    x3 = -x2 - A[0]
+    x4 = ax * bx * x1
+    x5 = numpy.exp(-x4 * (A[0] - B[0]) ** 2)
+    x6 = 1.772453850905516 * numpy.sqrt(x1)
+    x7 = x5 * x6
+    x8 = x3 * x7
+    x9 = -x2 - B[0]
+    x10 = x7 * x9
+    x11 = x0 * (x10 + x8)
+    x12 = x0 * x7
+    x13 = x8 * x9
+    x14 = x12 + x13
+    x15 = x14 * x3
+    x16 = x3**2 * x7
+    x17 = x12 + x16
+    x18 = x3 * (2.0 * x12 + x17)
+    x19 = 3.0 * x12
+    x20 = x11 + x15
+    x21 = x0 * (2.0 * x13 + x16 + x19) + x20 * x3
+    x22 = numpy.exp(-x4 * (A[1] - B[1]) ** 2)
+    x23 = da * db
+    x24 = numpy.exp(-x4 * (A[2] - B[2]) ** 2)
+    x25 = 3.141592653589793 * x1 * x24
+    x26 = x23 * x25
+    x27 = x22 * x26
+    x28 = 0.09759000729485332
+    x29 = x27 * x28
+    x30 = -x1 * (ax * A[1] + bx * B[1])
+    x31 = -x30 - B[1]
+    x32 = x29 * (x0 * (3.0 * x16 + x19) + x18 * x3)
+    x33 = -x1 * (ax * A[2] + bx * B[2])
+    x34 = -x33 - B[2]
+    x35 = -x30 - A[1]
+    x36 = 0.2581988897471611
+    x37 = x27 * x36
+    x38 = x21 * x37
+    x39 = x0 * x6
+    x40 = x22 * x39
+    x41 = x22 * x6
+    x42 = x35 * x41
+    x43 = x31 * x42
+    x44 = x40 + x43
+    x45 = x24 * x6
+    x46 = x23 * x36
+    x47 = x18 * x46
+    x48 = x18 * x37
+    x49 = -x33 - A[2]
+    x50 = x24 * x39
+    x51 = x45 * x49
+    x52 = x34 * x51
+    x53 = x50 + x52
+    x54 = x35**2 * x41
+    x55 = x40 + x54
+    x56 = 0.3333333333333333 * x23
+    x57 = x45 * x56
+    x58 = x31 * x41
+    x59 = x0 * (x42 + x58)
+    x60 = x35 * x44
+    x61 = x59 + x60
+    x62 = x34 * x45
+    x63 = x17 * x56
+    x64 = 1.732050807568877
+    x65 = x56 * x64
+    x66 = x35 * x65
+    x67 = x25 * x49
+    x68 = x63 * x64
+    x69 = x45 * x49**2
+    x70 = x50 + x69
+    x71 = x41 * x56
+    x72 = x0 * (x51 + x62)
+    x73 = x49 * x53
+    x74 = x72 + x73
+    x75 = x35 * (2.0 * x40 + x55)
+    x76 = x14 * x46
+    x77 = x3 * x5
+    x78 = 3.0 * x40
+    x79 = x0 * (2.0 * x43 + x54 + x78) + x35 * x61
+    x80 = x26 * x36
+    x81 = x79 * x80
+    x82 = x75 * x80
+    x83 = x55 * x56
+    x84 = x64 * x83
+    x85 = x65 * x70
+    x86 = 3.141592653589793 * x1 * x22
+    x87 = x77 * x86
+    x88 = x49 * (2.0 * x50 + x70)
+    x89 = x46 * x88
+    x90 = 3.0 * x50
+    x91 = x0 * (2.0 * x52 + x69 + x90) + x49 * x74
+    x92 = x46 * x91
+    x93 = x28 * x5
+    x94 = x26 * x93
+    x95 = x94 * (x0 * (3.0 * x54 + x78) + x35 * x75)
+    x96 = x49 * x5
+    x97 = x46 * x7
+    x98 = x56 * x7
+    x99 = x35 * x5 * x86
+    x100 = x23 * x86 * x93
+    x101 = x100 * (x0 * (3.0 * x69 + x90) + x49 * x88)
+
+    # 45 item(s)
+    result[0, 0] = numpy.sum(x29 * (x0 * (3.0 * x11 + 3.0 * x15 + x18) + x21 * x3))
+    result[0, 1] = numpy.sum(x31 * x32)
+    result[0, 2] = numpy.sum(x32 * x34)
+    result[1, 0] = numpy.sum(x35 * x38)
+    result[1, 1] = numpy.sum(x44 * x45 * x47)
+    result[1, 2] = numpy.sum(x34 * x35 * x48)
+    result[2, 0] = numpy.sum(x38 * x49)
+    result[2, 1] = numpy.sum(x31 * x48 * x49)
+    result[2, 2] = numpy.sum(x41 * x47 * x53)
+    result[3, 0] = numpy.sum(x20 * x55 * x57)
+    result[3, 1] = numpy.sum(x17 * x57 * x61)
+    result[3, 2] = numpy.sum(x55 * x62 * x63)
+    result[4, 0] = numpy.sum(x20 * x22 * x66 * x67)
+    result[4, 1] = numpy.sum(x44 * x51 * x68)
+    result[4, 2] = numpy.sum(x42 * x53 * x68)
+    result[5, 0] = numpy.sum(x20 * x70 * x71)
+    result[5, 1] = numpy.sum(x58 * x63 * x70)
+    result[5, 2] = numpy.sum(x17 * x71 * x74)
+    result[6, 0] = numpy.sum(x45 * x75 * x76)
+    result[6, 1] = numpy.sum(x77 * x81)
+    result[6, 2] = numpy.sum(x34 * x77 * x82)
+    result[7, 0] = numpy.sum(x14 * x51 * x84)
+    result[7, 1] = numpy.sum(x61 * x65 * x67 * x77)
+    result[7, 2] = numpy.sum(x53 * x8 * x84)
+    result[8, 0] = numpy.sum(x14 * x42 * x85)
+    result[8, 1] = numpy.sum(x44 * x8 * x85)
+    result[8, 2] = numpy.sum(x66 * x74 * x87)
+    result[9, 0] = numpy.sum(x41 * x76 * x88)
+    result[9, 1] = numpy.sum(x31 * x87 * x89)
+    result[9, 2] = numpy.sum(x87 * x92)
+    result[10, 0] = numpy.sum(x9 * x95)
+    result[10, 1] = numpy.sum(x94 * (x0 * (3.0 * x59 + 3.0 * x60 + x75) + x35 * x79))
+    result[10, 2] = numpy.sum(x34 * x95)
+    result[11, 0] = numpy.sum(x82 * x9 * x96)
+    result[11, 1] = numpy.sum(x81 * x96)
+    result[11, 2] = numpy.sum(x53 * x75 * x97)
+    result[12, 0] = numpy.sum(x10 * x70 * x83)
+    result[12, 1] = numpy.sum(x61 * x70 * x98)
+    result[12, 2] = numpy.sum(x55 * x74 * x98)
+    result[13, 0] = numpy.sum(x89 * x9 * x99)
+    result[13, 1] = numpy.sum(x44 * x88 * x97)
+    result[13, 2] = numpy.sum(x92 * x99)
+    result[14, 0] = numpy.sum(x101 * x9)
+    result[14, 1] = numpy.sum(x101 * x31)
+    result[14, 2] = numpy.sum(x100 * (x0 * (3.0 * x72 + 3.0 * x73 + x88) + x49 * x91))
+    return result
+
+
+def ovlp3d_42(ax, da, A, bx, db, B):
+    """Cartesian 3D (gd) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((15, 6), dtype=float)
+
+    x0 = 0.5 / (ax + bx)
+    x1 = (ax + bx) ** (-1.0)
+    x2 = -x1 * (ax * A[0] + bx * B[0])
+    x3 = -x2 - A[0]
+    x4 = ax * bx * x1
+    x5 = numpy.exp(-x4 * (A[0] - B[0]) ** 2)
+    x6 = 1.772453850905516 * numpy.sqrt(x1)
+    x7 = x5 * x6
+    x8 = x3**2 * x7
+    x9 = x0 * x7
+    x10 = 3.0 * x9
+    x11 = -x2 - B[0]
+    x12 = x3 * x7
+    x13 = x11 * x12
+    x14 = x10 + 2.0 * x13
+    x15 = x0 * (x14 + x8)
+    x16 = x11 * x7
+    x17 = x0 * (x12 + x16)
+    x18 = x13 + x9
+    x19 = x18 * x3
+    x20 = x17 + x19
+    x21 = x20 * x3
+    x22 = x11**2 * x7
+    x23 = x0 * (x14 + x22)
+    x24 = x11 * x18
+    x25 = x17 + x24
+    x26 = x25 * x3
+    x27 = x23 + x26
+    x28 = 2.0 * x0 * (2.0 * x17 + x19 + x24) + x27 * x3
+    x29 = da * db
+    x30 = 0.0563436169819011
+    x31 = x29 * x30
+    x32 = numpy.exp(-x4 * (A[1] - B[1]) ** 2)
+    x33 = numpy.exp(-x4 * (A[2] - B[2]) ** 2)
+    x34 = 3.141592653589793 * x1 * x33
+    x35 = x32 * x34
+    x36 = -x1 * (ax * A[1] + bx * B[1])
+    x37 = -x36 - B[1]
+    x38 = 0.09759000729485332
+    x39 = x37 * x38
+    x40 = x8 + x9
+    x41 = 2.0 * x0 * x12 + x3 * x40
+    x42 = x15 + x21
+    x43 = x29 * x35
+    x44 = x43 * (x0 * (3.0 * x17 + 3.0 * x19 + x41) + x3 * x42)
+    x45 = -x1 * (ax * A[2] + bx * B[2])
+    x46 = -x45 - B[2]
+    x47 = x38 * x46
+    x48 = x32 * x6
+    x49 = x37**2 * x48
+    x50 = x0 * x48
+    x51 = x49 + x50
+    x52 = x0 * (x10 + 3.0 * x8) + x3 * x41
+    x53 = x33 * x6
+    x54 = x29 * x53
+    x55 = x30 * x54
+    x56 = x46**2 * x53
+    x57 = x0 * x53
+    x58 = x56 + x57
+    x59 = x31 * x58
+    x60 = -x36 - A[1]
+    x61 = 2.23606797749979
+    x62 = 0.06666666666666667 * x29
+    x63 = x61 * x62
+    x64 = x60 * x63
+    x65 = x28 * x35
+    x66 = x48 * x60
+    x67 = x37 * x66
+    x68 = x50 + x67
+    x69 = 0.06666666666666667 * x54
+    x70 = 3.872983346207417
+    x71 = x42 * x70
+    x72 = x35 * x62 * x71
+    x73 = x37 * x48
+    x74 = x0 * (x66 + x73)
+    x75 = x37 * x68
+    x76 = x74 + x75
+    x77 = x41 * x61
+    x78 = x46 * x53
+    x79 = x62 * x78
+    x80 = x41 * x70
+    x81 = x62 * x77
+    x82 = -x45 - A[2]
+    x83 = x63 * x82
+    x84 = x53 * x82
+    x85 = x46 * x84
+    x86 = x57 + x85
+    x87 = x48 * x62
+    x88 = x62 * x73
+    x89 = x0 * (x78 + x84)
+    x90 = x46 * x86
+    x91 = x89 + x90
+    x92 = x48 * x60**2
+    x93 = x50 + x92
+    x94 = 1.732050807568877 * x29
+    x95 = 0.1111111111111111 * x93 * x94
+    x96 = x60 * x68
+    x97 = x74 + x96
+    x98 = 0.3333333333333333 * x20
+    x99 = x29 * x78
+    x100 = 3.0 * x50
+    x101 = x100 + 2.0 * x67
+    x102 = x0 * (x101 + x49)
+    x103 = x60 * x76
+    x104 = x102 + x103
+    x105 = x40 * x94
+    x106 = 0.1111111111111111 * x105
+    x107 = 0.3333333333333333 * x97
+    x108 = 0.3333333333333333 * x82
+    x109 = x68 * x94
+    x110 = 0.3333333333333333 * x86
+    x111 = x110 * x94
+    x112 = 0.3333333333333333 * x40
+    x113 = x29 * x76
+    x114 = x29 * x91
+    x115 = x53 * x82**2
+    x116 = x115 + x57
+    x117 = 0.1111111111111111 * x116 * x94
+    x118 = 0.3333333333333333 * x116
+    x119 = x118 * x29
+    x120 = x82 * x86
+    x121 = x120 + x89
+    x122 = x121 * x29
+    x123 = 3.0 * x57
+    x124 = x123 + 2.0 * x85
+    x125 = x0 * (x124 + x56)
+    x126 = x82 * x91
+    x127 = x125 + x126
+    x128 = x60 * (2.0 * x50 + x93)
+    x129 = x25 * x61
+    x130 = x0 * (x101 + x92)
+    x131 = x60 * x97
+    x132 = x130 + x131
+    x133 = x18 * x70
+    x134 = 2.0 * x0 * (2.0 * x74 + x75 + x96) + x104 * x60
+    x135 = x3 * x5
+    x136 = x135 * x34
+    x137 = x62 * x70
+    x138 = x132 * x137
+    x139 = x12 * x63
+    x140 = 0.3333333333333333 * x93
+    x141 = x18 * x94
+    x142 = 0.3333333333333333 * x121
+    x143 = 3.141592653589793 * x1 * x32
+    x144 = x135 * x143
+    x145 = x82 * (x116 + 2.0 * x57)
+    x146 = x0 * (x115 + x124)
+    x147 = x121 * x82
+    x148 = x146 + x147
+    x149 = x137 * x148
+    x150 = 2.0 * x0 * (x120 + 2.0 * x89 + x90) + x127 * x82
+    x151 = x22 + x9
+    x152 = x0 * (x100 + 3.0 * x92) + x128 * x60
+    x153 = x34 * x5
+    x154 = x11 * x153
+    x155 = x29 * (x0 * (x128 + 3.0 * x74 + 3.0 * x96) + x132 * x60)
+    x156 = x31 * x5
+    x157 = x151 * x63
+    x158 = x137 * x16
+    x159 = x62 * x7
+    x160 = x159 * x70
+    x161 = x159 * x61
+    x162 = x143 * x5
+    x163 = x11 * x162
+    x164 = x0 * (3.0 * x115 + x123) + x145 * x82
+    x165 = x164 * x31
+    x166 = x29 * (x0 * (3.0 * x120 + x145 + 3.0 * x89) + x148 * x82)
+
+    # 90 item(s)
+    result[0, 0] = numpy.sum(
+        x31 * x35 * (x0 * (2.0 * x15 + 2.0 * x21 + 3.0 * x23 + 3.0 * x26) + x28 * x3)
+    )
+    result[0, 1] = numpy.sum(x39 * x44)
+    result[0, 2] = numpy.sum(x44 * x47)
+    result[0, 3] = numpy.sum(x51 * x52 * x55)
+    result[0, 4] = numpy.sum(x39 * x43 * x46 * x52)
+    result[0, 5] = numpy.sum(x48 * x52 * x59)
+    result[1, 0] = numpy.sum(x64 * x65)
+    result[1, 1] = numpy.sum(x68 * x69 * x71)
+    result[1, 2] = numpy.sum(x46 * x60 * x72)
+    result[1, 3] = numpy.sum(x69 * x76 * x77)
+    result[1, 4] = numpy.sum(x68 * x79 * x80)
+    result[1, 5] = numpy.sum(x58 * x66 * x81)
+    result[2, 0] = numpy.sum(x65 * x83)
+    result[2, 1] = numpy.sum(x37 * x72 * x82)
+    result[2, 2] = numpy.sum(x71 * x86 * x87)
+    result[2, 3] = numpy.sum(x51 * x81 * x84)
+    result[2, 4] = numpy.sum(x80 * x86 * x88)
+    result[2, 5] = numpy.sum(x77 * x87 * x91)
+    result[3, 0] = numpy.sum(x27 * x53 * x95)
+    result[3, 1] = numpy.sum(x54 * x97 * x98)
+    result[3, 2] = numpy.sum(x93 * x98 * x99)
+    result[3, 3] = numpy.sum(x104 * x106 * x53)
+    result[3, 4] = numpy.sum(x107 * x40 * x99)
+    result[3, 5] = numpy.sum(x106 * x58 * x93)
+    result[4, 0] = numpy.sum(x108 * x27 * x43 * x60)
+    result[4, 1] = numpy.sum(x109 * x84 * x98)
+    result[4, 2] = numpy.sum(x111 * x20 * x66)
+    result[4, 3] = numpy.sum(x112 * x113 * x84)
+    result[4, 4] = numpy.sum(x105 * x110 * x68)
+    result[4, 5] = numpy.sum(x112 * x114 * x66)
+    result[5, 0] = numpy.sum(x117 * x27 * x48)
+    result[5, 1] = numpy.sum(x119 * x20 * x73)
+    result[5, 2] = numpy.sum(x122 * x48 * x98)
+    result[5, 3] = numpy.sum(x106 * x116 * x51)
+    result[5, 4] = numpy.sum(x112 * x122 * x73)
+    result[5, 5] = numpy.sum(x106 * x127 * x48)
+    result[6, 0] = numpy.sum(x128 * x129 * x69)
+    result[6, 1] = numpy.sum(x132 * x133 * x69)
+    result[6, 2] = numpy.sum(x128 * x133 * x79)
+    result[6, 3] = numpy.sum(x134 * x136 * x63)
+    result[6, 4] = numpy.sum(x136 * x138 * x46)
+    result[6, 5] = numpy.sum(x128 * x139 * x58)
+    result[7, 0] = numpy.sum(x140 * x25 * x29 * x84)
+    result[7, 1] = numpy.sum(x107 * x141 * x84)
+    result[7, 2] = numpy.sum(x110 * x141 * x93)
+    result[7, 3] = numpy.sum(x104 * x108 * x136 * x29)
+    result[7, 4] = numpy.sum(x111 * x12 * x97)
+    result[7, 5] = numpy.sum(x114 * x12 * x140)
+    result[8, 0] = numpy.sum(x119 * x25 * x66)
+    result[8, 1] = numpy.sum(x118 * x141 * x68)
+    result[8, 2] = numpy.sum(x141 * x142 * x66)
+    result[8, 3] = numpy.sum(x113 * x118 * x12)
+    result[8, 4] = numpy.sum(x109 * x12 * x142)
+    result[8, 5] = numpy.sum(0.3333333333333333 * x127 * x144 * x29 * x60)
+    result[9, 0] = numpy.sum(x129 * x145 * x87)
+    result[9, 1] = numpy.sum(x133 * x145 * x88)
+    result[9, 2] = numpy.sum(x133 * x148 * x87)
+    result[9, 3] = numpy.sum(x139 * x145 * x51)
+    result[9, 4] = numpy.sum(x144 * x149 * x37)
+    result[9, 5] = numpy.sum(x144 * x150 * x63)
+    result[10, 0] = numpy.sum(x151 * x152 * x55)
+    result[10, 1] = numpy.sum(x154 * x155 * x38)
+    result[10, 2] = numpy.sum(x152 * x154 * x29 * x47)
+    result[10, 3] = numpy.sum(
+        x156
+        * x34
+        * (x0 * (3.0 * x102 + 3.0 * x103 + 2.0 * x130 + 2.0 * x131) + x134 * x60)
+    )
+    result[10, 4] = numpy.sum(x153 * x155 * x47)
+    result[10, 5] = numpy.sum(x152 * x59 * x7)
+    result[11, 0] = numpy.sum(x128 * x157 * x84)
+    result[11, 1] = numpy.sum(x138 * x154 * x82)
+    result[11, 2] = numpy.sum(x128 * x158 * x86)
+    result[11, 3] = numpy.sum(x134 * x153 * x83)
+    result[11, 4] = numpy.sum(x132 * x160 * x86)
+    result[11, 5] = numpy.sum(x128 * x161 * x91)
+    result[12, 0] = numpy.sum(x116 * x151 * x95)
+    result[12, 1] = numpy.sum(x119 * x16 * x97)
+    result[12, 2] = numpy.sum(x122 * x140 * x16)
+    result[12, 3] = numpy.sum(x104 * x117 * x7)
+    result[12, 4] = numpy.sum(x107 * x122 * x7)
+    result[12, 5] = numpy.sum(x127 * x7 * x95)
+    result[13, 0] = numpy.sum(x145 * x157 * x66)
+    result[13, 1] = numpy.sum(x145 * x158 * x68)
+    result[13, 2] = numpy.sum(x149 * x163 * x60)
+    result[13, 3] = numpy.sum(x145 * x161 * x76)
+    result[13, 4] = numpy.sum(x148 * x160 * x68)
+    result[13, 5] = numpy.sum(x150 * x162 * x64)
+    result[14, 0] = numpy.sum(x151 * x165 * x48)
+    result[14, 1] = numpy.sum(x163 * x164 * x29 * x39)
+    result[14, 2] = numpy.sum(x163 * x166 * x38)
+    result[14, 3] = numpy.sum(x165 * x51 * x7)
+    result[14, 4] = numpy.sum(x162 * x166 * x39)
+    result[14, 5] = numpy.sum(
+        x143
+        * x156
+        * (x0 * (3.0 * x125 + 3.0 * x126 + 2.0 * x146 + 2.0 * x147) + x150 * x82)
+    )
+    return result
+
+
+def ovlp3d_43(ax, da, A, bx, db, B):
+    """Cartesian 3D (gf) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((15, 10), dtype=float)
+
+    x0 = 0.5 / (ax + bx)
+    x1 = (ax + bx) ** (-1.0)
+    x2 = -x1 * (ax * A[0] + bx * B[0])
+    x3 = -x2 - A[0]
+    x4 = -x2 - B[0]
+    x5 = ax * bx * x1
+    x6 = numpy.exp(-x5 * (A[0] - B[0]) ** 2)
+    x7 = 1.772453850905516 * numpy.sqrt(x1)
+    x8 = x6 * x7
+    x9 = x4**2 * x8
+    x10 = x0 * x8
+    x11 = 3.0 * x10
+    x12 = x3 * x8
+    x13 = x12 * x4
+    x14 = x11 + 2.0 * x13
+    x15 = x0 * (x14 + x9)
+    x16 = x4 * x8
+    x17 = x0 * (x12 + x16)
+    x18 = x10 + x13
+    x19 = x18 * x4
+    x20 = x17 + x19
+    x21 = x20 * x3
+    x22 = x15 + x21
+    x23 = x22 * x3
+    x24 = x22 * x4
+    x25 = x18 * x3
+    x26 = 2.0 * x0 * (2.0 * x17 + x19 + x25)
+    x27 = x20 * x4
+    x28 = 3.0 * x21
+    x29 = x24 + x26
+    x30 = x0 * (5.0 * x15 + 2.0 * x27 + x28) + x29 * x3
+    x31 = da * db
+    x32 = 0.009523809523809524 * x31
+    x33 = 2.645751311064591 * x32
+    x34 = numpy.exp(-x5 * (A[1] - B[1]) ** 2)
+    x35 = numpy.exp(-x5 * (A[2] - B[2]) ** 2)
+    x36 = 3.141592653589793 * x1 * x35
+    x37 = x34 * x36
+    x38 = -x1 * (ax * A[1] + bx * B[1])
+    x39 = -x38 - B[1]
+    x40 = x37 * x39
+    x41 = x3**2 * x8
+    x42 = x0 * (x14 + x41)
+    x43 = x17 + x25
+    x44 = x3 * x43
+    x45 = x23 + x26
+    x46 = 5.916079783099616
+    x47 = x32 * x46
+    x48 = x47 * (x0 * (3.0 * x15 + x28 + 2.0 * x42 + 2.0 * x44) + x3 * x45)
+    x49 = -x1 * (ax * A[2] + bx * B[2])
+    x50 = -x49 - B[2]
+    x51 = x37 * x50
+    x52 = x34 * x7
+    x53 = x39**2 * x52
+    x54 = x0 * x52
+    x55 = x53 + x54
+    x56 = x31 * x55
+    x57 = x35 * x7
+    x58 = x46 * x57
+    x59 = x10 + x41
+    x60 = 2.0 * x0
+    x61 = x12 * x60 + x3 * x59
+    x62 = x42 + x44
+    x63 = x0 * (3.0 * x17 + 3.0 * x25 + x61) + x3 * x62
+    x64 = 0.009523809523809524 * x63
+    x65 = 10.2469507659596 * x32
+    x66 = x50 * x65
+    x67 = x50**2 * x57
+    x68 = x0 * x57
+    x69 = x67 + x68
+    x70 = x31 * x69
+    x71 = x46 * x70
+    x72 = 2.0 * x54
+    x73 = x39 * (x55 + x72)
+    x74 = x0 * (x11 + 3.0 * x41) + x3 * x61
+    x75 = x33 * x74
+    x76 = 0.009523809523809524 * x74
+    x77 = x50 * x57
+    x78 = x46 * x77
+    x79 = x39 * x52
+    x80 = 2.0 * x68
+    x81 = x50 * (x69 + x80)
+    x82 = -x38 - A[1]
+    x83 = 0.06666666666666667 * x31
+    x84 = x82 * x83
+    x85 = x30 * x37
+    x86 = x52 * x82
+    x87 = x39 * x86
+    x88 = x54 + x87
+    x89 = 0.149071198499986
+    x90 = x31 * x89
+    x91 = x57 * x90
+    x92 = x45 * x90
+    x93 = x0 * (x79 + x86)
+    x94 = x39 * x88
+    x95 = x93 + x94
+    x96 = 3.872983346207417
+    x97 = x83 * x96
+    x98 = x62 * x97
+    x99 = x62 * x89
+    x100 = 0.06666666666666667 * x57
+    x101 = 3.0 * x54
+    x102 = x101 + 2.0 * x87
+    x103 = x0 * (x102 + x53)
+    x104 = x39 * x95
+    x105 = x103 + x104
+    x106 = x105 * x31
+    x107 = x61 * x89
+    x108 = x107 * x31
+    x109 = x61 * x83
+    x110 = -x49 - A[2]
+    x111 = x110 * x83
+    x112 = x110 * x57
+    x113 = x112 * x50
+    x114 = x113 + x68
+    x115 = x52 * x90
+    x116 = x0 * (x112 + x77)
+    x117 = x114 * x50
+    x118 = x116 + x117
+    x119 = 0.06666666666666667 * x52
+    x120 = 3.0 * x68
+    x121 = 2.0 * x113 + x120
+    x122 = x0 * (x121 + x67)
+    x123 = x118 * x50
+    x124 = x122 + x123
+    x125 = x124 * x31
+    x126 = x52 * x82**2
+    x127 = x126 + x54
+    x128 = x127 * x31
+    x129 = 0.02222222222222222 * x96
+    x130 = x128 * x129
+    x131 = x82 * x88
+    x132 = x131 + x93
+    x133 = x31 * x57
+    x134 = 1.732050807568877
+    x135 = 0.1111111111111111 * x134
+    x136 = x135 * x22
+    x137 = x82 * x95
+    x138 = x103 + x137
+    x139 = x134 * x43
+    x140 = 0.1111111111111111 * x139
+    x141 = 0.3333333333333333 * x31
+    x142 = x141 * x43
+    x143 = 0.1111111111111111 * x70
+    x144 = 2.0 * x0 * (x131 + 2.0 * x93 + x94)
+    x145 = x138 * x39
+    x146 = x144 + x145
+    x147 = x129 * x59
+    x148 = x138 * x31
+    x149 = x134 * x59
+    x150 = 0.1111111111111111 * x149
+    x151 = x110 * x90
+    x152 = x141 * x88
+    x153 = x114 * x141
+    x154 = x59 * x89
+    x155 = x141 * x59
+    x156 = x110**2 * x57
+    x157 = x156 + x68
+    x158 = x157 * x31
+    x159 = x129 * x158
+    x160 = x110 * x114
+    x161 = x116 + x160
+    x162 = x31 * x52
+    x163 = 0.1111111111111111 * x56
+    x164 = x110 * x118
+    x165 = x122 + x164
+    x166 = x165 * x31
+    x167 = 2.0 * x0 * (2.0 * x116 + x117 + x160)
+    x168 = x165 * x50
+    x169 = x167 + x168
+    x170 = x15 + x27
+    x171 = x82 * (x127 + x72)
+    x172 = x171 * x31
+    x173 = x0 * (x102 + x126)
+    x174 = x132 * x82
+    x175 = x173 + x174
+    x176 = x20 * x89
+    x177 = x138 * x82
+    x178 = x144 + x177
+    x179 = x18 * x89
+    x180 = x18 * x97
+    x181 = x3 * x83
+    x182 = 3.0 * x137
+    x183 = x0 * (5.0 * x103 + 2.0 * x104 + x182) + x146 * x82
+    x184 = x36 * x6
+    x185 = x183 * x184
+    x186 = x184 * x3
+    x187 = x12 * x89
+    x188 = 0.06666666666666667 * x12
+    x189 = x170 * x89
+    x190 = x112 * x141
+    x191 = x127 * x141
+    x192 = x134 * x18
+    x193 = x12 * x141
+    x194 = x141 * x157
+    x195 = x141 * x86
+    x196 = 3.141592653589793 * x1 * x34 * x6
+    x197 = x196 * x3 * x90
+    x198 = x110 * (x157 + x80)
+    x199 = x198 * x31
+    x200 = x0 * (x121 + x156)
+    x201 = x110 * x161
+    x202 = x200 + x201
+    x203 = x110 * x165
+    x204 = x167 + x203
+    x205 = 3.0 * x164
+    x206 = x0 * (5.0 * x122 + 2.0 * x123 + x205) + x110 * x169
+    x207 = x196 * x206
+    x208 = x10 + x9
+    x209 = x16 * x60 + x208 * x4
+    x210 = x0 * (x101 + 3.0 * x126) + x171 * x82
+    x211 = x210 * x33
+    x212 = x0 * (3.0 * x131 + x171 + 3.0 * x93) + x175 * x82
+    x213 = x208 * x32
+    x214 = x4 * x47
+    x215 = x184 * (x0 * (3.0 * x103 + 2.0 * x173 + 2.0 * x174 + x182) + x178 * x82)
+    x216 = x184 * x4
+    x217 = 0.009523809523809524 * x16
+    x218 = 0.009523809523809524 * x8
+    x219 = 0.06666666666666667 * x209
+    x220 = x208 * x89
+    x221 = x220 * x31
+    x222 = x16 * x97
+    x223 = x16 * x89
+    x224 = x8 * x90
+    x225 = 0.06666666666666667 * x8
+    x226 = x135 * x208
+    x227 = x135 * x16
+    x228 = x135 * x8
+    x229 = x196 * x4
+    x230 = x0 * (x120 + 3.0 * x156) + x110 * x198
+    x231 = x230 * x33
+    x232 = x230 * x46
+    x233 = x0 * (3.0 * x116 + 3.0 * x160 + x198) + x110 * x202
+    x234 = x233 * x46
+    x235 = x196 * (x0 * (3.0 * x122 + 2.0 * x200 + 2.0 * x201 + x205) + x110 * x204)
+
+    # 150 item(s)
+    result[0, 0] = numpy.sum(x33 * x37 * (3.0 * x0 * (x23 + x24 + 2.0 * x26) + x3 * x30))
+    result[0, 1] = numpy.sum(x40 * x48)
+    result[0, 2] = numpy.sum(x48 * x51)
+    result[0, 3] = numpy.sum(x56 * x58 * x64)
+    result[0, 4] = numpy.sum(x40 * x63 * x66)
+    result[0, 5] = numpy.sum(x52 * x64 * x71)
+    result[0, 6] = numpy.sum(x57 * x73 * x75)
+    result[0, 7] = numpy.sum(x56 * x76 * x78)
+    result[0, 8] = numpy.sum(x71 * x76 * x79)
+    result[0, 9] = numpy.sum(x52 * x75 * x81)
+    result[1, 0] = numpy.sum(x84 * x85)
+    result[1, 1] = numpy.sum(x45 * x88 * x91)
+    result[1, 2] = numpy.sum(x51 * x82 * x92)
+    result[1, 3] = numpy.sum(x62 * x91 * x95)
+    result[1, 4] = numpy.sum(x77 * x88 * x98)
+    result[1, 5] = numpy.sum(x70 * x86 * x99)
+    result[1, 6] = numpy.sum(x100 * x106 * x61)
+    result[1, 7] = numpy.sum(x108 * x77 * x95)
+    result[1, 8] = numpy.sum(x107 * x70 * x88)
+    result[1, 9] = numpy.sum(x109 * x81 * x86)
+    result[2, 0] = numpy.sum(x111 * x85)
+    result[2, 1] = numpy.sum(x110 * x40 * x92)
+    result[2, 2] = numpy.sum(x114 * x115 * x45)
+    result[2, 3] = numpy.sum(x112 * x56 * x99)
+    result[2, 4] = numpy.sum(x114 * x79 * x98)
+    result[2, 5] = numpy.sum(x115 * x118 * x62)
+    result[2, 6] = numpy.sum(x109 * x112 * x73)
+    result[2, 7] = numpy.sum(x107 * x114 * x56)
+    result[2, 8] = numpy.sum(x108 * x118 * x79)
+    result[2, 9] = numpy.sum(x119 * x125 * x61)
+    result[3, 0] = numpy.sum(x130 * x29 * x57)
+    result[3, 1] = numpy.sum(x132 * x133 * x136)
+    result[3, 2] = numpy.sum(x128 * x136 * x77)
+    result[3, 3] = numpy.sum(x133 * x138 * x140)
+    result[3, 4] = numpy.sum(x132 * x142 * x77)
+    result[3, 5] = numpy.sum(x127 * x139 * x143)
+    result[3, 6] = numpy.sum(x133 * x146 * x147)
+    result[3, 7] = numpy.sum(x148 * x150 * x77)
+    result[3, 8] = numpy.sum(x132 * x143 * x149)
+    result[3, 9] = numpy.sum(x128 * x147 * x81)
+    result[4, 0] = numpy.sum(x151 * x29 * x37 * x82)
+    result[4, 1] = numpy.sum(x112 * x152 * x22)
+    result[4, 2] = numpy.sum(x153 * x22 * x86)
+    result[4, 3] = numpy.sum(x112 * x142 * x95)
+    result[4, 4] = numpy.sum(x139 * x153 * x88)
+    result[4, 5] = numpy.sum(x118 * x142 * x86)
+    result[4, 6] = numpy.sum(x106 * x112 * x154)
+    result[4, 7] = numpy.sum(x114 * x155 * x95)
+    result[4, 8] = numpy.sum(x118 * x155 * x88)
+    result[4, 9] = numpy.sum(x125 * x154 * x86)
+    result[5, 0] = numpy.sum(x159 * x29 * x52)
+    result[5, 1] = numpy.sum(x136 * x158 * x79)
+    result[5, 2] = numpy.sum(x136 * x161 * x162)
+    result[5, 3] = numpy.sum(x139 * x157 * x163)
+    result[5, 4] = numpy.sum(x142 * x161 * x79)
+    result[5, 5] = numpy.sum(x140 * x162 * x165)
+    result[5, 6] = numpy.sum(x147 * x158 * x73)
+    result[5, 7] = numpy.sum(x149 * x161 * x163)
+    result[5, 8] = numpy.sum(x150 * x166 * x79)
+    result[5, 9] = numpy.sum(x147 * x162 * x169)
+    result[6, 0] = numpy.sum(x100 * x170 * x172)
+    result[6, 1] = numpy.sum(x175 * x20 * x91)
+    result[6, 2] = numpy.sum(x172 * x176 * x77)
+    result[6, 3] = numpy.sum(x133 * x178 * x179)
+    result[6, 4] = numpy.sum(x175 * x180 * x77)
+    result[6, 5] = numpy.sum(x171 * x179 * x70)
+    result[6, 6] = numpy.sum(x181 * x185)
+    result[6, 7] = numpy.sum(x178 * x186 * x50 * x90)
+    result[6, 8] = numpy.sum(x175 * x187 * x70)
+    result[6, 9] = numpy.sum(x172 * x188 * x81)
+    result[7, 0] = numpy.sum(x112 * x128 * x189)
+    result[7, 1] = numpy.sum(x132 * x190 * x20)
+    result[7, 2] = numpy.sum(x114 * x191 * x20)
+    result[7, 3] = numpy.sum(x138 * x18 * x190)
+    result[7, 4] = numpy.sum(x132 * x153 * x192)
+    result[7, 5] = numpy.sum(x118 * x18 * x191)
+    result[7, 6] = numpy.sum(x146 * x151 * x186)
+    result[7, 7] = numpy.sum(x12 * x138 * x153)
+    result[7, 8] = numpy.sum(x118 * x132 * x193)
+    result[7, 9] = numpy.sum(x124 * x128 * x187)
+    result[8, 0] = numpy.sum(x158 * x189 * x86)
+    result[8, 1] = numpy.sum(x194 * x20 * x88)
+    result[8, 2] = numpy.sum(x161 * x195 * x20)
+    result[8, 3] = numpy.sum(x18 * x194 * x95)
+    result[8, 4] = numpy.sum(x152 * x161 * x192)
+    result[8, 5] = numpy.sum(x165 * x18 * x195)
+    result[8, 6] = numpy.sum(x105 * x158 * x187)
+    result[8, 7] = numpy.sum(x161 * x193 * x95)
+    result[8, 8] = numpy.sum(x12 * x152 * x165)
+    result[8, 9] = numpy.sum(x169 * x197 * x82)
+    result[9, 0] = numpy.sum(x119 * x170 * x199)
+    result[9, 1] = numpy.sum(x176 * x199 * x79)
+    result[9, 2] = numpy.sum(x115 * x20 * x202)
+    result[9, 3] = numpy.sum(x179 * x198 * x56)
+    result[9, 4] = numpy.sum(x180 * x202 * x79)
+    result[9, 5] = numpy.sum(x162 * x179 * x204)
+    result[9, 6] = numpy.sum(x188 * x199 * x73)
+    result[9, 7] = numpy.sum(x187 * x202 * x56)
+    result[9, 8] = numpy.sum(x197 * x204 * x39)
+    result[9, 9] = numpy.sum(x181 * x207)
+    result[10, 0] = numpy.sum(x209 * x211 * x57)
+    result[10, 1] = numpy.sum(x212 * x213 * x58)
+    result[10, 2] = numpy.sum(x210 * x213 * x78)
+    result[10, 3] = numpy.sum(x214 * x215)
+    result[10, 4] = numpy.sum(x212 * x216 * x66)
+    result[10, 5] = numpy.sum(x210 * x217 * x71)
+    result[10, 6] = numpy.sum(
+        x184 * x33 * (3.0 * x0 * (2.0 * x144 + x145 + x177) + x183 * x82)
+    )
+    result[10, 7] = numpy.sum(x215 * x47 * x50)
+    result[10, 8] = numpy.sum(x212 * x218 * x71)
+    result[10, 9] = numpy.sum(x211 * x8 * x81)
+    result[11, 0] = numpy.sum(x112 * x172 * x219)
+    result[11, 1] = numpy.sum(x112 * x175 * x221)
+    result[11, 2] = numpy.sum(x114 * x172 * x220)
+    result[11, 3] = numpy.sum(x151 * x178 * x216)
+    result[11, 4] = numpy.sum(x114 * x175 * x222)
+    result[11, 5] = numpy.sum(x118 * x172 * x223)
+    result[11, 6] = numpy.sum(x111 * x185)
+    result[11, 7] = numpy.sum(x114 * x178 * x224)
+    result[11, 8] = numpy.sum(x118 * x175 * x224)
+    result[11, 9] = numpy.sum(x124 * x172 * x225)
+    result[12, 0] = numpy.sum(x130 * x157 * x209)
+    result[12, 1] = numpy.sum(x132 * x158 * x226)
+    result[12, 2] = numpy.sum(x128 * x161 * x226)
+    result[12, 3] = numpy.sum(x138 * x158 * x227)
+    result[12, 4] = numpy.sum(x132 * x141 * x16 * x161)
+    result[12, 5] = numpy.sum(x128 * x165 * x227)
+    result[12, 6] = numpy.sum(x146 * x159 * x8)
+    result[12, 7] = numpy.sum(x148 * x161 * x228)
+    result[12, 8] = numpy.sum(x132 * x166 * x228)
+    result[12, 9] = numpy.sum(x130 * x169 * x8)
+    result[13, 0] = numpy.sum(x199 * x219 * x86)
+    result[13, 1] = numpy.sum(x199 * x220 * x88)
+    result[13, 2] = numpy.sum(x202 * x221 * x86)
+    result[13, 3] = numpy.sum(x199 * x223 * x95)
+    result[13, 4] = numpy.sum(x202 * x222 * x88)
+    result[13, 5] = numpy.sum(x204 * x229 * x82 * x90)
+    result[13, 6] = numpy.sum(x105 * x199 * x225)
+    result[13, 7] = numpy.sum(x202 * x224 * x95)
+    result[13, 8] = numpy.sum(x204 * x224 * x88)
+    result[13, 9] = numpy.sum(x207 * x84)
+    result[14, 0] = numpy.sum(x209 * x231 * x52)
+    result[14, 1] = numpy.sum(x213 * x232 * x79)
+    result[14, 2] = numpy.sum(x213 * x234 * x52)
+    result[14, 3] = numpy.sum(x217 * x232 * x56)
+    result[14, 4] = numpy.sum(x229 * x233 * x39 * x65)
+    result[14, 5] = numpy.sum(x214 * x235)
+    result[14, 6] = numpy.sum(x231 * x73 * x8)
+    result[14, 7] = numpy.sum(x218 * x234 * x56)
+    result[14, 8] = numpy.sum(x235 * x39 * x47)
+    result[14, 9] = numpy.sum(
+        x196 * x33 * (3.0 * x0 * (2.0 * x167 + x168 + x203) + x110 * x206)
+    )
+    return result
+
+
+def ovlp3d_44(ax, da, A, bx, db, B):
+    """Cartesian 3D (gg) overlap integral.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((15, 15), dtype=float)
+
+    x0 = 0.5 / (ax + bx)
+    x1 = (ax + bx) ** (-1.0)
+    x2 = -x1 * (ax * A[0] + bx * B[0])
+    x3 = -x2 - B[0]
+    x4 = -x2 - A[0]
+    x5 = ax * bx * x1
+    x6 = numpy.exp(-x5 * (A[0] - B[0]) ** 2)
+    x7 = 1.772453850905516 * numpy.sqrt(x1)
+    x8 = x6 * x7
+    x9 = x0 * x8
+    x10 = x4 * x8
+    x11 = x10 * x3
+    x12 = x11 + x9
+    x13 = x12 * x4
+    x14 = x12 * x3
+    x15 = x3 * x8
+    x16 = x0 * (x10 + x15)
+    x17 = 2.0 * x0 * (x13 + x14 + 2.0 * x16)
+    x18 = x3**2 * x8
+    x19 = 3.0 * x9
+    x20 = 2.0 * x11 + x19
+    x21 = x0 * (x18 + x20)
+    x22 = x14 + x16
+    x23 = x22 * x4
+    x24 = x21 + x23
+    x25 = x24 * x3
+    x26 = x17 + x25
+    x27 = x26 * x3
+    x28 = x26 * x4
+    x29 = x22 * x3
+    x30 = 3.0 * x23
+    x31 = x0 * (5.0 * x21 + 2.0 * x29 + x30)
+    x32 = x24 * x4
+    x33 = 3.0 * x0 * (2.0 * x17 + x25 + x32)
+    x34 = x28 + x31
+    x35 = x3 * x34 + x33
+    x36 = numpy.exp(-x5 * (A[1] - B[1]) ** 2)
+    x37 = da * db
+    x38 = 0.009523809523809524 * x37
+    x39 = numpy.exp(-x5 * (A[2] - B[2]) ** 2)
+    x40 = 3.141592653589793 * x1 * x39
+    x41 = x38 * x40
+    x42 = x36 * x41
+    x43 = -x1 * (ax * A[1] + bx * B[1])
+    x44 = -x43 - B[1]
+    x45 = 2.645751311064591
+    x46 = x42 * x45
+    x47 = x46 * (x33 + x34 * x4)
+    x48 = -x1 * (ax * A[2] + bx * B[2])
+    x49 = -x48 - B[2]
+    x50 = x4**2 * x8
+    x51 = x0 * (x20 + x50)
+    x52 = x13 + x16
+    x53 = x4 * x52
+    x54 = x17 + x32
+    x55 = x0 * (3.0 * x21 + x30 + 2.0 * x51 + 2.0 * x53) + x4 * x54
+    x56 = x39 * x7
+    x57 = 0.03253000243161777
+    x58 = x36 * x7
+    x59 = x44**2 * x58
+    x60 = x0 * x58
+    x61 = x59 + x60
+    x62 = x37 * x61
+    x63 = x57 * x62
+    x64 = 5.916079783099616
+    x65 = x42 * x64
+    x66 = x49**2 * x56
+    x67 = x0 * x56
+    x68 = x66 + x67
+    x69 = x37 * x68
+    x70 = x57 * x69
+    x71 = 2.0 * x60
+    x72 = x44 * (x61 + x71)
+    x73 = 3.0 * x16
+    x74 = x50 + x9
+    x75 = 2.0 * x9
+    x76 = x4 * (x74 + x75)
+    x77 = x51 + x53
+    x78 = x0 * (3.0 * x13 + x73 + x76) + x4 * x77
+    x79 = x38 * x45
+    x80 = x78 * x79
+    x81 = x49 * x56
+    x82 = 0.009523809523809524 * x64
+    x83 = x78 * x82
+    x84 = x44 * x58
+    x85 = 2.0 * x67
+    x86 = x49 * (x68 + x85)
+    x87 = 3.0 * x60
+    x88 = x0 * (3.0 * x59 + x87) + x44 * x72
+    x89 = x0 * (x19 + 3.0 * x50) + x4 * x76
+    x90 = x38 * x89
+    x91 = x45 * x90
+    x92 = 3.0 * x67
+    x93 = x0 * (3.0 * x66 + x92) + x49 * x86
+    x94 = -x43 - A[1]
+    x95 = x35 * x46
+    x96 = x58 * x94
+    x97 = x44 * x96
+    x98 = x60 + x97
+    x99 = x37 * x98
+    x100 = 0.06666666666666667 * x56
+    x101 = 0.06666666666666667 * x37
+    x102 = x101 * x40
+    x103 = x102 * x49
+    x104 = x34 * x36
+    x105 = x0 * (x84 + x96)
+    x106 = x44 * x98
+    x107 = x105 + x106
+    x108 = 0.08606629658238704
+    x109 = x108 * x37
+    x110 = x109 * x54
+    x111 = 0.149071198499986
+    x112 = x111 * x54
+    x113 = x108 * x54
+    x114 = x87 + 2.0 * x97
+    x115 = x0 * (x114 + x59)
+    x116 = x107 * x44
+    x117 = x115 + x116
+    x118 = x37 * x77
+    x119 = x111 * x77
+    x120 = x119 * x37
+    x121 = 0.06666666666666667 * x118
+    x122 = 3.0 * x105
+    x123 = x0 * (3.0 * x106 + x122 + x72) + x117 * x44
+    x124 = x76 * x79
+    x125 = 0.06666666666666667 * x76
+    x126 = x125 * x37
+    x127 = x108 * x76
+    x128 = -x48 - A[2]
+    x129 = x102 * x128
+    x130 = x128 * x56
+    x131 = x130 * x49
+    x132 = x131 + x67
+    x133 = x132 * x37
+    x134 = 0.06666666666666667 * x58
+    x135 = x0 * (x130 + x81)
+    x136 = x132 * x49
+    x137 = x135 + x136
+    x138 = 2.0 * x131 + x92
+    x139 = x0 * (x138 + x66)
+    x140 = x137 * x49
+    x141 = x139 + x140
+    x142 = 3.0 * x135
+    x143 = x0 * (3.0 * x136 + x142 + x86) + x141 * x49
+    x144 = x27 + x31
+    x145 = x58 * x94**2
+    x146 = x145 + x60
+    x147 = x146 * x37
+    x148 = x147 * x57
+    x149 = x94 * x98
+    x150 = x105 + x149
+    x151 = x109 * x56
+    x152 = x108 * x81
+    x153 = x107 * x94
+    x154 = x115 + x153
+    x155 = 0.1111111111111111 * x37
+    x156 = x155 * x24
+    x157 = 1.732050807568877
+    x158 = x155 * x157
+    x159 = x158 * x24
+    x160 = x155 * x68
+    x161 = 2.0 * x0 * (2.0 * x105 + x106 + x149)
+    x162 = x154 * x44
+    x163 = x161 + x162
+    x164 = x157 * x52
+    x165 = x154 * x155
+    x166 = x108 * x86
+    x167 = 3.0 * x153
+    x168 = x0 * (5.0 * x115 + 2.0 * x116 + x167)
+    x169 = x163 * x44
+    x170 = x168 + x169
+    x171 = x37 * x74
+    x172 = x171 * x57
+    x173 = x111 * x26
+    x174 = x107 * x158
+    x175 = 0.3333333333333333 * x99
+    x176 = x137 * x158
+    x177 = x111 * x37
+    x178 = x177 * x52
+    x179 = 0.3333333333333333 * x133
+    x180 = x171 * x82
+    x181 = x111 * x74
+    x182 = x128**2 * x56
+    x183 = x182 + x67
+    x184 = x183 * x37
+    x185 = x184 * x57
+    x186 = x108 * x84
+    x187 = x128 * x132
+    x188 = x135 + x187
+    x189 = x109 * x58
+    x190 = x155 * x61
+    x191 = x128 * x137
+    x192 = x139 + x191
+    x193 = x108 * x72
+    x194 = 2.0 * x0 * (2.0 * x135 + x136 + x187)
+    x195 = x192 * x49
+    x196 = x194 + x195
+    x197 = 3.0 * x191
+    x198 = x0 * (5.0 * x139 + 2.0 * x140 + x197)
+    x199 = x196 * x49
+    x200 = x198 + x199
+    x201 = x94 * (x146 + x71)
+    x202 = x18 + x9
+    x203 = x3 * (x202 + x75)
+    x204 = x21 + x29
+    x205 = x0 * (3.0 * x14 + x203 + x73) + x204 * x3
+    x206 = x205 * x79
+    x207 = x0 * (x114 + x145)
+    x208 = x150 * x94
+    x209 = x207 + x208
+    x210 = x204 * x37
+    x211 = 0.06666666666666667 * x201
+    x212 = x154 * x94
+    x213 = x161 + x212
+    x214 = x108 * x22
+    x215 = x214 * x37
+    x216 = x177 * x22
+    x217 = x163 * x94
+    x218 = x168 + x217
+    x219 = x12 * x37
+    x220 = x111 * x219
+    x221 = x4 * x45
+    x222 = 3.0 * x0 * (2.0 * x161 + x162 + x212)
+    x223 = x218 * x44 + x222
+    x224 = x41 * x6
+    x225 = x223 * x224
+    x226 = x218 * x6
+    x227 = x10 * x108
+    x228 = x10 * x101
+    x229 = x10 * x79
+    x230 = x147 * x82
+    x231 = x111 * x204
+    x232 = x231 * x37
+    x233 = x158 * x22
+    x234 = 0.3333333333333333 * x219
+    x235 = x4 * x64
+    x236 = x10 * x111
+    x237 = x10 * x177
+    x238 = x184 * x82
+    x239 = 3.141592653589793 * x1 * x36 * x6
+    x240 = x239 * x38
+    x241 = x128 * (x183 + x85)
+    x242 = 0.06666666666666667 * x241
+    x243 = x0 * (x138 + x182)
+    x244 = x128 * x188
+    x245 = x243 + x244
+    x246 = x128 * x192
+    x247 = x194 + x246
+    x248 = x128 * x196
+    x249 = x198 + x248
+    x250 = x101 * x239 * x249
+    x251 = 3.0 * x0 * (2.0 * x194 + x195 + x246)
+    x252 = x249 * x49 + x251
+    x253 = x240 * x252
+    x254 = x0 * (3.0 * x18 + x19) + x203 * x3
+    x255 = x0 * (3.0 * x145 + x87) + x201 * x94
+    x256 = x255 * x38
+    x257 = x0 * (x122 + 3.0 * x149 + x201) + x209 * x94
+    x258 = x257 * x79
+    x259 = x256 * x45
+    x260 = x0 * (3.0 * x115 + x167 + 2.0 * x207 + 2.0 * x208) + x213 * x94
+    x261 = x202 * x37 * x57
+    x262 = x202 * x38 * x64
+    x263 = x3 * x45
+    x264 = x224 * (x218 * x94 + x222)
+    x265 = x3 * x64
+    x266 = x15 * x82
+    x267 = x254 * x79
+    x268 = x101 * x203
+    x269 = x109 * x202
+    x270 = x111 * x202
+    x271 = x111 * x15
+    x272 = x15 * x37
+    x273 = x111 * x272
+    x274 = 0.06666666666666667 * x8
+    x275 = x109 * x8
+    x276 = x274 * x37
+    x277 = x79 * x8
+    x278 = x108 * x203
+    x279 = x155 * x202
+    x280 = x108 * x15
+    x281 = x15 * x158
+    x282 = x0 * (3.0 * x182 + x92) + x128 * x241
+    x283 = x282 * x38
+    x284 = x283 * x45
+    x285 = x0 * (x142 + 3.0 * x187 + x241) + x128 * x245
+    x286 = x0 * (3.0 * x139 + x197 + 2.0 * x243 + 2.0 * x244) + x128 * x247
+    x287 = x240 * (x128 * x249 + x251)
+
+    # 225 item(s)
+    result[0, 0] = numpy.sum(x42 * (x0 * (3.0 * x27 + 4.0 * x28 + 7.0 * x31) + x35 * x4))
+    result[0, 1] = numpy.sum(x44 * x47)
+    result[0, 2] = numpy.sum(x47 * x49)
+    result[0, 3] = numpy.sum(x55 * x56 * x63)
+    result[0, 4] = numpy.sum(x44 * x49 * x55 * x65)
+    result[0, 5] = numpy.sum(x55 * x58 * x70)
+    result[0, 6] = numpy.sum(x56 * x72 * x80)
+    result[0, 7] = numpy.sum(x62 * x81 * x83)
+    result[0, 8] = numpy.sum(x69 * x83 * x84)
+    result[0, 9] = numpy.sum(x58 * x80 * x86)
+    result[0, 10] = numpy.sum(x56 * x88 * x90)
+    result[0, 11] = numpy.sum(x72 * x81 * x91)
+    result[0, 12] = numpy.sum(x61 * x70 * x89)
+    result[0, 13] = numpy.sum(x84 * x86 * x91)
+    result[0, 14] = numpy.sum(x58 * x90 * x93)
+    result[1, 0] = numpy.sum(x94 * x95)
+    result[1, 1] = numpy.sum(x100 * x34 * x99)
+    result[1, 2] = numpy.sum(x103 * x104 * x94)
+    result[1, 3] = numpy.sum(x107 * x110 * x56)
+    result[1, 4] = numpy.sum(x112 * x81 * x99)
+    result[1, 5] = numpy.sum(x113 * x69 * x96)
+    result[1, 6] = numpy.sum(x100 * x117 * x118)
+    result[1, 7] = numpy.sum(x107 * x120 * x81)
+    result[1, 8] = numpy.sum(x119 * x68 * x99)
+    result[1, 9] = numpy.sum(x121 * x86 * x96)
+    result[1, 10] = numpy.sum(x123 * x124 * x56)
+    result[1, 11] = numpy.sum(x117 * x126 * x81)
+    result[1, 12] = numpy.sum(x107 * x127 * x69)
+    result[1, 13] = numpy.sum(x125 * x86 * x99)
+    result[1, 14] = numpy.sum(x124 * x93 * x96)
+    result[2, 0] = numpy.sum(x128 * x95)
+    result[2, 1] = numpy.sum(x104 * x129 * x44)
+    result[2, 2] = numpy.sum(x133 * x134 * x34)
+    result[2, 3] = numpy.sum(x113 * x130 * x62)
+    result[2, 4] = numpy.sum(x112 * x133 * x84)
+    result[2, 5] = numpy.sum(x110 * x137 * x58)
+    result[2, 6] = numpy.sum(x121 * x130 * x72)
+    result[2, 7] = numpy.sum(x119 * x133 * x61)
+    result[2, 8] = numpy.sum(x120 * x137 * x84)
+    result[2, 9] = numpy.sum(x118 * x134 * x141)
+    result[2, 10] = numpy.sum(x124 * x130 * x88)
+    result[2, 11] = numpy.sum(x125 * x133 * x72)
+    result[2, 12] = numpy.sum(x127 * x137 * x62)
+    result[2, 13] = numpy.sum(x126 * x141 * x84)
+    result[2, 14] = numpy.sum(x124 * x143 * x58)
+    result[3, 0] = numpy.sum(x144 * x148 * x56)
+    result[3, 1] = numpy.sum(x150 * x151 * x26)
+    result[3, 2] = numpy.sum(x147 * x152 * x26)
+    result[3, 3] = numpy.sum(x154 * x156 * x56)
+    result[3, 4] = numpy.sum(x150 * x159 * x81)
+    result[3, 5] = numpy.sum(x146 * x160 * x24)
+    result[3, 6] = numpy.sum(x151 * x163 * x52)
+    result[3, 7] = numpy.sum(x164 * x165 * x81)
+    result[3, 8] = numpy.sum(x150 * x160 * x164)
+    result[3, 9] = numpy.sum(x147 * x166 * x52)
+    result[3, 10] = numpy.sum(x170 * x172 * x56)
+    result[3, 11] = numpy.sum(x152 * x163 * x171)
+    result[3, 12] = numpy.sum(x154 * x160 * x74)
+    result[3, 13] = numpy.sum(x150 * x166 * x171)
+    result[3, 14] = numpy.sum(x148 * x74 * x93)
+    result[4, 0] = numpy.sum(x128 * x144 * x65 * x94)
+    result[4, 1] = numpy.sum(x130 * x173 * x99)
+    result[4, 2] = numpy.sum(x133 * x173 * x96)
+    result[4, 3] = numpy.sum(x130 * x174 * x24)
+    result[4, 4] = numpy.sum(x132 * x175 * x24)
+    result[4, 5] = numpy.sum(x176 * x24 * x96)
+    result[4, 6] = numpy.sum(x117 * x130 * x178)
+    result[4, 7] = numpy.sum(x107 * x179 * x52)
+    result[4, 8] = numpy.sum(x137 * x175 * x52)
+    result[4, 9] = numpy.sum(x141 * x178 * x96)
+    result[4, 10] = numpy.sum(x123 * x130 * x180)
+    result[4, 11] = numpy.sum(x117 * x133 * x181)
+    result[4, 12] = numpy.sum(x107 * x176 * x74)
+    result[4, 13] = numpy.sum(x141 * x181 * x99)
+    result[4, 14] = numpy.sum(x143 * x180 * x96)
+    result[5, 0] = numpy.sum(x144 * x185 * x58)
+    result[5, 1] = numpy.sum(x184 * x186 * x26)
+    result[5, 2] = numpy.sum(x188 * x189 * x26)
+    result[5, 3] = numpy.sum(x183 * x190 * x24)
+    result[5, 4] = numpy.sum(x159 * x188 * x84)
+    result[5, 5] = numpy.sum(x156 * x192 * x58)
+    result[5, 6] = numpy.sum(x184 * x193 * x52)
+    result[5, 7] = numpy.sum(x164 * x188 * x190)
+    result[5, 8] = numpy.sum(x155 * x164 * x192 * x84)
+    result[5, 9] = numpy.sum(x189 * x196 * x52)
+    result[5, 10] = numpy.sum(x172 * x183 * x88)
+    result[5, 11] = numpy.sum(x171 * x188 * x193)
+    result[5, 12] = numpy.sum(x190 * x192 * x74)
+    result[5, 13] = numpy.sum(x171 * x186 * x196)
+    result[5, 14] = numpy.sum(x172 * x200 * x58)
+    result[6, 0] = numpy.sum(x201 * x206 * x56)
+    result[6, 1] = numpy.sum(x100 * x209 * x210)
+    result[6, 2] = numpy.sum(x210 * x211 * x81)
+    result[6, 3] = numpy.sum(x213 * x215 * x56)
+    result[6, 4] = numpy.sum(x209 * x216 * x81)
+    result[6, 5] = numpy.sum(x201 * x214 * x69)
+    result[6, 6] = numpy.sum(x100 * x218 * x219)
+    result[6, 7] = numpy.sum(x213 * x220 * x81)
+    result[6, 8] = numpy.sum(x209 * x220 * x68)
+    result[6, 9] = numpy.sum(x211 * x219 * x86)
+    result[6, 10] = numpy.sum(x221 * x225)
+    result[6, 11] = numpy.sum(x103 * x226 * x4)
+    result[6, 12] = numpy.sum(x213 * x227 * x69)
+    result[6, 13] = numpy.sum(x209 * x228 * x86)
+    result[6, 14] = numpy.sum(x201 * x229 * x93)
+    result[7, 0] = numpy.sum(x130 * x205 * x230)
+    result[7, 1] = numpy.sum(x130 * x150 * x232)
+    result[7, 2] = numpy.sum(x133 * x146 * x231)
+    result[7, 3] = numpy.sum(x130 * x154 * x233)
+    result[7, 4] = numpy.sum(x150 * x179 * x22)
+    result[7, 5] = numpy.sum(x146 * x176 * x22)
+    result[7, 6] = numpy.sum(x130 * x163 * x220)
+    result[7, 7] = numpy.sum(x12 * x154 * x179)
+    result[7, 8] = numpy.sum(x137 * x150 * x234)
+    result[7, 9] = numpy.sum(x141 * x146 * x220)
+    result[7, 10] = numpy.sum(x128 * x170 * x224 * x235)
+    result[7, 11] = numpy.sum(x133 * x163 * x236)
+    result[7, 12] = numpy.sum(x10 * x154 * x176)
+    result[7, 13] = numpy.sum(x141 * x150 * x237)
+    result[7, 14] = numpy.sum(x10 * x143 * x230)
+    result[8, 0] = numpy.sum(x205 * x238 * x96)
+    result[8, 1] = numpy.sum(x183 * x231 * x99)
+    result[8, 2] = numpy.sum(x188 * x232 * x96)
+    result[8, 3] = numpy.sum(x174 * x183 * x22)
+    result[8, 4] = numpy.sum(x175 * x188 * x22)
+    result[8, 5] = numpy.sum(x192 * x233 * x96)
+    result[8, 6] = numpy.sum(x117 * x183 * x220)
+    result[8, 7] = numpy.sum(x107 * x188 * x234)
+    result[8, 8] = numpy.sum(x12 * x175 * x192)
+    result[8, 9] = numpy.sum(x196 * x220 * x96)
+    result[8, 10] = numpy.sum(x10 * x123 * x238)
+    result[8, 11] = numpy.sum(x117 * x188 * x237)
+    result[8, 12] = numpy.sum(x10 * x174 * x192)
+    result[8, 13] = numpy.sum(x196 * x236 * x99)
+    result[8, 14] = numpy.sum(x200 * x235 * x240 * x94)
+    result[9, 0] = numpy.sum(x206 * x241 * x58)
+    result[9, 1] = numpy.sum(x210 * x242 * x84)
+    result[9, 2] = numpy.sum(x134 * x210 * x245)
+    result[9, 3] = numpy.sum(x214 * x241 * x62)
+    result[9, 4] = numpy.sum(x216 * x245 * x84)
+    result[9, 5] = numpy.sum(x215 * x247 * x58)
+    result[9, 6] = numpy.sum(x219 * x242 * x72)
+    result[9, 7] = numpy.sum(x220 * x245 * x61)
+    result[9, 8] = numpy.sum(x220 * x247 * x84)
+    result[9, 9] = numpy.sum(x134 * x219 * x249)
+    result[9, 10] = numpy.sum(x229 * x241 * x88)
+    result[9, 11] = numpy.sum(x228 * x245 * x72)
+    result[9, 12] = numpy.sum(x227 * x247 * x62)
+    result[9, 13] = numpy.sum(x250 * x4 * x44)
+    result[9, 14] = numpy.sum(x221 * x253)
+    result[10, 0] = numpy.sum(x254 * x256 * x56)
+    result[10, 1] = numpy.sum(x203 * x258 * x56)
+    result[10, 2] = numpy.sum(x203 * x259 * x81)
+    result[10, 3] = numpy.sum(x260 * x261 * x56)
+    result[10, 4] = numpy.sum(x257 * x262 * x81)
+    result[10, 5] = numpy.sum(x202 * x255 * x70)
+    result[10, 6] = numpy.sum(x263 * x264)
+    result[10, 7] = numpy.sum(x224 * x260 * x265 * x49)
+    result[10, 8] = numpy.sum(x257 * x266 * x69)
+    result[10, 9] = numpy.sum(x15 * x259 * x86)
+    result[10, 10] = numpy.sum(
+        x224 * (x0 * (7.0 * x168 + 3.0 * x169 + 4.0 * x217) + x223 * x94)
+    )
+    result[10, 11] = numpy.sum(x264 * x45 * x49)
+    result[10, 12] = numpy.sum(x260 * x70 * x8)
+    result[10, 13] = numpy.sum(x258 * x8 * x86)
+    result[10, 14] = numpy.sum(x256 * x8 * x93)
+    result[11, 0] = numpy.sum(x130 * x201 * x267)
+    result[11, 1] = numpy.sum(x130 * x209 * x268)
+    result[11, 2] = numpy.sum(x133 * x203 * x211)
+    result[11, 3] = numpy.sum(x130 * x213 * x269)
+    result[11, 4] = numpy.sum(x133 * x209 * x270)
+    result[11, 5] = numpy.sum(x137 * x201 * x269)
+    result[11, 6] = numpy.sum(x129 * x226 * x3)
+    result[11, 7] = numpy.sum(x133 * x213 * x271)
+    result[11, 8] = numpy.sum(x137 * x209 * x273)
+    result[11, 9] = numpy.sum(x141 * x211 * x272)
+    result[11, 10] = numpy.sum(x128 * x225 * x45)
+    result[11, 11] = numpy.sum(x133 * x218 * x274)
+    result[11, 12] = numpy.sum(x137 * x213 * x275)
+    result[11, 13] = numpy.sum(x141 * x209 * x276)
+    result[11, 14] = numpy.sum(x143 * x201 * x277)
+    result[12, 0] = numpy.sum(x148 * x183 * x254)
+    result[12, 1] = numpy.sum(x150 * x184 * x278)
+    result[12, 2] = numpy.sum(x147 * x188 * x278)
+    result[12, 3] = numpy.sum(x154 * x183 * x279)
+    result[12, 4] = numpy.sum(x150 * x157 * x188 * x279)
+    result[12, 5] = numpy.sum(x146 * x192 * x279)
+    result[12, 6] = numpy.sum(x163 * x184 * x280)
+    result[12, 7] = numpy.sum(x154 * x188 * x281)
+    result[12, 8] = numpy.sum(x150 * x192 * x281)
+    result[12, 9] = numpy.sum(x147 * x196 * x280)
+    result[12, 10] = numpy.sum(x170 * x185 * x8)
+    result[12, 11] = numpy.sum(x163 * x188 * x275)
+    result[12, 12] = numpy.sum(x165 * x192 * x8)
+    result[12, 13] = numpy.sum(x150 * x196 * x275)
+    result[12, 14] = numpy.sum(x148 * x200 * x8)
+    result[13, 0] = numpy.sum(x241 * x267 * x96)
+    result[13, 1] = numpy.sum(x203 * x242 * x99)
+    result[13, 2] = numpy.sum(x245 * x268 * x96)
+    result[13, 3] = numpy.sum(x107 * x241 * x269)
+    result[13, 4] = numpy.sum(x245 * x270 * x99)
+    result[13, 5] = numpy.sum(x247 * x269 * x96)
+    result[13, 6] = numpy.sum(x117 * x242 * x272)
+    result[13, 7] = numpy.sum(x107 * x245 * x273)
+    result[13, 8] = numpy.sum(x247 * x271 * x99)
+    result[13, 9] = numpy.sum(x250 * x3 * x94)
+    result[13, 10] = numpy.sum(x123 * x241 * x277)
+    result[13, 11] = numpy.sum(x117 * x245 * x276)
+    result[13, 12] = numpy.sum(x107 * x247 * x275)
+    result[13, 13] = numpy.sum(x249 * x274 * x99)
+    result[13, 14] = numpy.sum(x253 * x45 * x94)
+    result[14, 0] = numpy.sum(x254 * x283 * x58)
+    result[14, 1] = numpy.sum(x203 * x284 * x84)
+    result[14, 2] = numpy.sum(x203 * x285 * x58 * x79)
+    result[14, 3] = numpy.sum(x202 * x282 * x63)
+    result[14, 4] = numpy.sum(x262 * x285 * x84)
+    result[14, 5] = numpy.sum(x261 * x286 * x58)
+    result[14, 6] = numpy.sum(x15 * x284 * x72)
+    result[14, 7] = numpy.sum(x266 * x285 * x62)
+    result[14, 8] = numpy.sum(x240 * x265 * x286 * x44)
+    result[14, 9] = numpy.sum(x263 * x287)
+    result[14, 10] = numpy.sum(x283 * x8 * x88)
+    result[14, 11] = numpy.sum(x277 * x285 * x72)
+    result[14, 12] = numpy.sum(x286 * x63 * x8)
+    result[14, 13] = numpy.sum(x287 * x44 * x45)
+    result[14, 14] = numpy.sum(
+        x240 * (x0 * (7.0 * x198 + 3.0 * x199 + 4.0 * x248) + x128 * x252)
+    )
+    return result
+
+
+ovlp3d = {
+    (0, 0): ovlp3d_00,
+    (0, 1): ovlp3d_01,
+    (0, 2): ovlp3d_02,
+    (0, 3): ovlp3d_03,
+    (0, 4): ovlp3d_04,
+    (1, 0): ovlp3d_10,
+    (1, 1): ovlp3d_11,
+    (1, 2): ovlp3d_12,
+    (1, 3): ovlp3d_13,
+    (1, 4): ovlp3d_14,
+    (2, 0): ovlp3d_20,
+    (2, 1): ovlp3d_21,
+    (2, 2): ovlp3d_22,
+    (2, 3): ovlp3d_23,
+    (2, 4): ovlp3d_24,
+    (3, 0): ovlp3d_30,
+    (3, 1): ovlp3d_31,
+    (3, 2): ovlp3d_32,
+    (3, 3): ovlp3d_33,
+    (3, 4): ovlp3d_34,
+    (4, 0): ovlp3d_40,
+    (4, 1): ovlp3d_41,
+    (4, 2): ovlp3d_42,
+    (4, 3): ovlp3d_43,
+    (4, 4): ovlp3d_44,
+}