raddy 0.0.0-beta2

/*

* Code generated by Symars. Thank you for using Symars!
  Symars is licensed under MIT licnese.
  Repository: https://github.com/Da1sypetals/Symars

* Computation code is not intended for manual editing.

* If you find an error,
  or if you believe Symars generates incorrect result,
  please raise an issue under our repo with minimal reproducible example.

*/
#![allow(unused)]
#![cfg_attr(rustfmt, rustfmt_skip)]

#[inline]
pub fn grad_costan(s: f64) -> f64 {
    let __intermediate_result_4 = (s).tan();

    ((((1.0000000000000000000_f64) + ((__intermediate_result_4).powi(2))) * ((s).cos()))
        + (-(((s).sin()) * (__intermediate_result_4))))
}

#[inline]
pub fn hess_costan(s: f64) -> f64 {
    let __intermediate_result_2 = (s).cos();
    let __intermediate_result_3 = (s).tan();
    let __intermediate_result_6 = ((s).tan()).powi(2);

    ((-((__intermediate_result_2) * (__intermediate_result_3)))
        + ((-2.0000000000000000000_f64)
            * ((1.0000000000000000000_f64) + (__intermediate_result_6))
            * ((s).sin()))
        + (((2.0000000000000000000_f64)
            + ((2.0000000000000000000_f64) * (__intermediate_result_6)))
            * (__intermediate_result_2)
            * (__intermediate_result_3)))
}

#[inline]
pub fn grad_alpha(s: f64) -> f64 {
    let __intermediate_result_2 =
        ((1.0000000000000000000_f64) + (-((s).powi(2)))).powf(-0.50000000000000000000_f64);
    let __intermediate_result_6 = (s).tan();

    (((__intermediate_result_2) * (__intermediate_result_6))
        + (((1.0000000000000000000_f64) + ((__intermediate_result_6).powi(2))) * ((s).asin()))
        + (-((s) * (__intermediate_result_2)))
        + ((s).acos()))
}

#[inline]
pub fn hess_alpha(s: f64) -> f64 {
    let __intermediate_result_2 =
        ((1.0000000000000000000_f64) + (-((s).powi(2)))).powf(-0.50000000000000000000_f64);
    let __intermediate_result_7 =
        ((1.0000000000000000000_f64) + (-((s).powi(2)))).powf(-1.5000000000000000000_f64);
    let __intermediate_result_10 = ((s).tan()).powi(2);
    let __intermediate_result_11 = (s).tan();

    (((-2.0000000000000000000_f64) * (__intermediate_result_2))
        + (-(((s).powi(2)) * (__intermediate_result_7)))
        + ((2.0000000000000000000_f64)
            * (__intermediate_result_2)
            * ((1.0000000000000000000_f64) + (__intermediate_result_10)))
        + ((s) * (__intermediate_result_7) * (__intermediate_result_11))
        + (((2.0000000000000000000_f64)
            + ((2.0000000000000000000_f64) * (__intermediate_result_10)))
            * ((s).asin())
            * (__intermediate_result_11)))
}

#[inline]
pub fn grad_beta(s: f64) -> f64 {
    let __intermediate_result_2 = (s).cosh();
    let __intermediate_result_5 = (s).recip();
    let __intermediate_result_8 = (s).sinh();

    (((__intermediate_result_2).powi(-3))
        + (((s).atan2((__intermediate_result_5))) * (__intermediate_result_2))
        + ((-3.0000000000000000000_f64)
            * (s)
            * ((__intermediate_result_2).powi(-4))
            * (__intermediate_result_8))
        + ((2.0000000000000000000_f64)
            * (__intermediate_result_5)
            * ((((s).powi(-2)) + ((s).powi(2))).recip())
            * (__intermediate_result_8)))
}

#[inline]
pub fn hess_beta(s: f64) -> f64 {
    let __intermediate_result_3 = (s).recip();
    let __intermediate_result_4 = (s).sinh();
    let __intermediate_result_7 = (s).cosh();
    let __intermediate_result_12 = (((s).powi(-2)) + ((s).powi(2))).recip();

    ((((s).atan2((__intermediate_result_3))) * (__intermediate_result_4))
        + ((-6.0000000000000000000_f64)
            * ((__intermediate_result_7).powi(-4))
            * (__intermediate_result_4))
        + ((-3.0000000000000000000_f64) * (s) * ((__intermediate_result_7).powi(-3)))
        + ((-2.0000000000000000000_f64)
            * ((s).powi(-2))
            * (__intermediate_result_12)
            * (__intermediate_result_4))
        + ((4.0000000000000000000_f64)
            * (__intermediate_result_3)
            * (__intermediate_result_12)
            * (__intermediate_result_7))
        + ((12.000000000000000000_f64)
            * (s)
            * ((__intermediate_result_7).powi(-5))
            * ((__intermediate_result_4).powi(2)))
        + ((2.0000000000000000000_f64)
            * (__intermediate_result_3)
            * ((((s).powi(-2)) + ((s).powi(2))).powi(-2))
            * (((-2.0000000000000000000_f64) * (s))
                + ((2.0000000000000000000_f64) * ((s).powi(-3))))
            * (__intermediate_result_4)))
}

#[inline]
pub fn grad_kappa(s: f64) -> f64 {
    let __intermediate_result_2 = (s).tanh();
    let __intermediate_result_4 = (s).powi(-2);
    let __intermediate_result_11 = (((s).powi(2)) + (((s).asinh()).powi(2))).recip();
    let __intermediate_result_15 = (s).asinh();

    (((__intermediate_result_2).powi(-3))
        + ((__intermediate_result_4)
            * (((1.0000000000000000000_f64) + (-(__intermediate_result_4))).recip()))
        + ((((__intermediate_result_11) * (__intermediate_result_15))
            + (-((s)
                * (((1.0000000000000000000_f64) + ((s).powi(2)))
                    .powf(-0.50000000000000000000_f64))
                * (__intermediate_result_11))))
            * ((s).acosh()))
        + ((s)
            * ((__intermediate_result_2).powi(-4))
            * ((-3.0000000000000000000_f64)
                + ((3.0000000000000000000_f64) * ((__intermediate_result_2).powi(2)))))
        + ((((1.0000000000000000000_f64) + (s)).powf(-0.50000000000000000000_f64))
            * (((-1.0000000000000000000_f64) + (s)).powf(-0.50000000000000000000_f64))
            * ((s).atan2((__intermediate_result_15)))))
}

/*

* Code generated by Symars. Thank you for using Symars!
  Symars is licensed under MIT licnese.
  Repository: https://github.com/Da1sypetals/Symars

* Computation code is not intended for manual editing.

* If you find an error,
  or if you believe Symars generates incorrect result,
  please raise an issue under our repo with minimal reproducible example.

*/

#[inline]
pub fn hess_kappa(s: f64) -> f64 {
    let __intermediate_result_7 = (((s).powi(2)) + (((s).asinh()).powi(2))).recip();
    let __intermediate_result_10 = (s).asinh();
    let __intermediate_result_12 = (((s).powi(2)) + (((s).asinh()).powi(2))).powi(-2);
    let __intermediate_result_13 = (((-2.0000000000000000000_f64) * (s))
        + ((-2.0000000000000000000_f64)
            * (((1.0000000000000000000_f64) + ((s).powi(2))).powf(-0.50000000000000000000_f64))
            * ((s).asinh())));
    let __intermediate_result_16 =
        ((1.0000000000000000000_f64) + ((s).powi(2))).powf(-0.50000000000000000000_f64);
    let __intermediate_result_22 = ((1.0000000000000000000_f64) + (-((s).powi(-2))));
    let __intermediate_result_30 = (s).tanh();
    let __intermediate_result_31 =
        ((-3.0000000000000000000_f64) + ((3.0000000000000000000_f64) * (((s).tanh()).powi(2))));
    let __intermediate_result_33 = ((s).tanh()).powi(2);
    let __intermediate_result_35 =
        ((1.0000000000000000000_f64) + (s)).powf(-0.50000000000000000000_f64);
    let __intermediate_result_37 =
        ((-1.0000000000000000000_f64) + (s)).powf(-0.50000000000000000000_f64);
    let __intermediate_result_48 = (s).atan2((s).asinh());

    ((((((s).powi(2))
        * (((1.0000000000000000000_f64) + ((s).powi(2))).powf(-1.5000000000000000000_f64))
        * (__intermediate_result_7))
        + ((__intermediate_result_12) * (__intermediate_result_13) * (__intermediate_result_10))
        + (-((s)
            * (__intermediate_result_16)
            * (__intermediate_result_12)
            * (__intermediate_result_13))))
        * ((s).acosh()))
        + ((-2.0000000000000000000_f64) * ((s).powi(-5)) * ((__intermediate_result_22).powi(-2)))
        + ((-2.0000000000000000000_f64) * ((s).powi(-3)) * ((__intermediate_result_22).recip()))
        + ((2.0000000000000000000_f64)
            * ((__intermediate_result_30).powi(-4))
            * (__intermediate_result_31))
        + ((2.0000000000000000000_f64)
            * (__intermediate_result_35)
            * (__intermediate_result_37)
            * (((__intermediate_result_7) * (__intermediate_result_10))
                + (-((s) * (__intermediate_result_16) * (__intermediate_result_7)))))
        + ((3.0000000000000000000_f64)
            * (s)
            * ((__intermediate_result_30).powi(-3))
            * ((2.0000000000000000000_f64)
                + ((-2.0000000000000000000_f64) * (__intermediate_result_33))))
        + ((-0.50000000000000000000_f64)
            * (((1.0000000000000000000_f64) + (s)).powf(-1.5000000000000000000_f64))
            * (__intermediate_result_37)
            * (__intermediate_result_48))
        + ((-0.50000000000000000000_f64)
            * (__intermediate_result_35)
            * (((-1.0000000000000000000_f64) + (s)).powf(-1.5000000000000000000_f64))
            * (__intermediate_result_48))
        + ((s)
            * ((__intermediate_result_30).powi(-5))
            * ((-4.0000000000000000000_f64)
                + ((4.0000000000000000000_f64) * (__intermediate_result_33)))
            * (__intermediate_result_31)))
}

#[inline]
pub fn grad_0(s: f64) -> f64 {
    let __intermediate_result_5 = (s).powi(2);
    let __intermediate_result_7 = (s).cosh();
    let __intermediate_result_10 = (s).sinh();

    ((1.0000000000000000000_f64)
        + (-(((s).tanh()).powi(2)))
        + ((1.24500000000000_f64)
            * (__intermediate_result_5)
            * ((__intermediate_result_7).powi(2)))
        + ((1.24500000000000_f64)
            * (__intermediate_result_5)
            * ((__intermediate_result_10).powi(2)))
        + ((2.49000000000000_f64) * (s) * (__intermediate_result_7) * (__intermediate_result_10)))
}

#[inline]
pub fn hess_0(s: f64) -> f64 {
    let __intermediate_result_5 = (s).tanh();
    let __intermediate_result_7 = (s).cosh();
    let __intermediate_result_8 = (s).sinh();

    ((-(((2.0000000000000000000_f64)
        + ((-2.0000000000000000000_f64) * ((__intermediate_result_5).powi(2))))
        * (__intermediate_result_5)))
        + ((2.49000000000000_f64) * (__intermediate_result_7) * (__intermediate_result_8))
        + ((4.98000000000000_f64) * (s) * ((__intermediate_result_7).powi(2)))
        + ((4.98000000000000_f64) * (s) * ((__intermediate_result_8).powi(2)))
        + ((4.98000000000000_f64)
            * ((s).powi(2))
            * (__intermediate_result_7)
            * (__intermediate_result_8)))
}

pub fn grad_1(s: f64) -> f64 {
    (((0.50000000000000000000_f64) * ((s).powf(-0.50000000000000000000_f64)))
        + (((s).powf(1.30000000000000_f64)) * ((s).sin()))
        + (((s).asinh()) * ((s).tan()))
        + ((-1.30000000000000_f64) * ((s).powf(0.300000000000000_f64)) * ((s).cos()))
        + ((s)
            * (((1.0000000000000000000_f64) + ((s).powi(2))).powf(-0.50000000000000000000_f64))
            * ((s).tan()))
        + ((s) * ((1.0000000000000000000_f64) + (((s).tan()).powi(2))) * ((s).asinh())))
}

pub fn hess_1(s: f64) -> f64 {
    let __intermediate_result_8 = ((1.0000000000000000000_f64) + ((s).powi(2)));
    let __intermediate_result_10 = (s).tan();
    let __intermediate_result_13 = ((s).tan()).powi(2);

    (((-0.25000000000000000000_f64) * ((s).powf(-1.5000000000000000000_f64)))
        + (((s).powf(1.30000000000000_f64)) * ((s).cos()))
        + ((2.0000000000000000000_f64)
            * ((__intermediate_result_8).powf(-0.50000000000000000000_f64))
            * (__intermediate_result_10))
        + ((2.0000000000000000000_f64)
            * ((1.0000000000000000000_f64) + (__intermediate_result_13))
            * ((s).asinh()))
        + ((2.60000000000000_f64) * ((s).powf(0.300000000000000_f64)) * ((s).sin()))
        + ((-0.390000000000000_f64) * ((s).powf(-0.700000000000000_f64)) * ((s).cos()))
        + (-(((s).powi(2))
            * ((__intermediate_result_8).powf(-1.5000000000000000000_f64))
            * (__intermediate_result_10)))
        + ((2.0000000000000000000_f64)
            * (s)
            * ((__intermediate_result_8).powf(-0.50000000000000000000_f64))
            * ((1.0000000000000000000_f64) + (__intermediate_result_13)))
        + ((s)
            * ((2.0000000000000000000_f64)
                + ((2.0000000000000000000_f64) * (__intermediate_result_13)))
            * ((s).asinh())
            * (__intermediate_result_10)))
}

pub fn grad_2(s: f64) -> f64 {
    let __intermediate_result_12 = (s).powi(2);
    let __intermediate_result_15 = (s).atanh();
    let __intermediate_result_16 = (s).tan();
    let __intermediate_result_21 = (s).asinh();

    ((-0.693962526023595_f64)
        + ((0.50000000000000000000_f64) * ((s).powf(-0.50000000000000000000_f64)))
        + ((-5.23500000000000_f64) * ((s).powi(-2)))
        + (((s).powf(1.30000000000000_f64)) * ((s).sin()))
        + ((-1.30000000000000_f64) * ((s).powf(0.300000000000000_f64)) * ((s).cos()))
        + ((__intermediate_result_12)
            * (((1.0000000000000000000_f64) + (__intermediate_result_12))
                .powf(-0.50000000000000000000_f64))
            * (__intermediate_result_15)
            * (__intermediate_result_16))
        + ((__intermediate_result_12)
            * (((1.0000000000000000000_f64) + (-(__intermediate_result_12))).recip())
            * (__intermediate_result_21)
            * (__intermediate_result_16))
        + ((__intermediate_result_12)
            * ((1.0000000000000000000_f64) + ((__intermediate_result_16).powi(2)))
            * (__intermediate_result_21)
            * (__intermediate_result_15))
        + ((2.0000000000000000000_f64)
            * (s)
            * (__intermediate_result_21)
            * (__intermediate_result_15)
            * (__intermediate_result_16)))
}

pub fn hess_2(s: f64) -> f64 {
    let __intermediate_result_7 = (s).cos();
    let __intermediate_result_14 = (s).asinh();
    let __intermediate_result_15 = (s).atanh();
    let __intermediate_result_16 = (s).tan();
    let __intermediate_result_18 = (s).powi(3);
    let __intermediate_result_21 = (s).powi(2);
    let __intermediate_result_23 =
        ((1.0000000000000000000_f64) + ((s).powi(2))).powf(-0.50000000000000000000_f64);
    let __intermediate_result_24 = ((1.0000000000000000000_f64) + (-((s).powi(2)))).recip();
    let __intermediate_result_28 = ((1.0000000000000000000_f64) + (((s).tan()).powi(2)));

    (((-0.25000000000000000000_f64) * ((s).powf(-1.5000000000000000000_f64)))
        + ((10.4700000000000_f64) * ((s).powi(-3)))
        + (((s).powf(1.30000000000000_f64)) * (__intermediate_result_7))
        + ((2.60000000000000_f64) * ((s).powf(0.300000000000000_f64)) * ((s).sin()))
        + ((-0.390000000000000_f64)
            * ((s).powf(-0.700000000000000_f64))
            * (__intermediate_result_7))
        + ((2.0000000000000000000_f64)
            * (__intermediate_result_14)
            * (__intermediate_result_15)
            * (__intermediate_result_16))
        + (-((__intermediate_result_18)
            * (((1.0000000000000000000_f64) + (__intermediate_result_21))
                .powf(-1.5000000000000000000_f64))
            * (__intermediate_result_15)
            * (__intermediate_result_16)))
        + ((2.0000000000000000000_f64)
            * (__intermediate_result_21)
            * (__intermediate_result_23)
            * (__intermediate_result_24)
            * (__intermediate_result_16))
        + ((2.0000000000000000000_f64)
            * (__intermediate_result_21)
            * (__intermediate_result_23)
            * (__intermediate_result_28)
            * (__intermediate_result_15))
        + ((2.0000000000000000000_f64)
            * (__intermediate_result_21)
            * (__intermediate_result_24)
            * (__intermediate_result_28)
            * (__intermediate_result_14))
        + ((2.0000000000000000000_f64)
            * (__intermediate_result_18)
            * (((1.0000000000000000000_f64) + (-(__intermediate_result_21))).powi(-2))
            * (__intermediate_result_14)
            * (__intermediate_result_16))
        + ((4.0000000000000000000_f64)
            * (s)
            * (__intermediate_result_23)
            * (__intermediate_result_15)
            * (__intermediate_result_16))
        + ((4.0000000000000000000_f64)
            * (s)
            * (__intermediate_result_24)
            * (__intermediate_result_14)
            * (__intermediate_result_16))
        + ((4.0000000000000000000_f64)
            * (s)
            * (__intermediate_result_28)
            * (__intermediate_result_14)
            * (__intermediate_result_15))
        + ((__intermediate_result_21)
            * ((2.0000000000000000000_f64)
                + ((2.0000000000000000000_f64) * ((__intermediate_result_16).powi(2))))
            * (__intermediate_result_14)
            * (__intermediate_result_15)
            * (__intermediate_result_16)))
}

pub fn grad_3(s: f64) -> f64 {
    let __intermediate_result_9 = (s).powf(1.30000000000000_f64);
    let __intermediate_result_12 = (s).powi(2);
    let __intermediate_result_14 = (s).powi(3);
    let __intermediate_result_17 = (s).cos();
    let __intermediate_result_19 = ((s).asinh()).powi(2);
    let __intermediate_result_23 = (s).tan();

    (((-0.693962526023595_f64)
        + ((0.50000000000000000000_f64) * ((s).powf(-0.50000000000000000000_f64)))
        + ((-27.7760000000000_f64) * ((s).powf(-3.24000000000000_f64)))
        + ((-5.23500000000000_f64) * ((s).powi(-2)))
        + ((__intermediate_result_9) * ((s).sin()))
        + ((-3.0000000000000000000_f64)
            * (__intermediate_result_12)
            * ((__intermediate_result_14).cosh()))
        + ((-1.30000000000000_f64)
            * ((s).powf(0.300000000000000_f64))
            * (__intermediate_result_17))
        + ((__intermediate_result_12)
            * (__intermediate_result_19)
            * ((1.0000000000000000000_f64) + ((__intermediate_result_23).powi(2))))
        + ((2.0000000000000000000_f64)
            * (s)
            * (__intermediate_result_19)
            * (__intermediate_result_23))
        + ((2.0000000000000000000_f64)
            * (__intermediate_result_12)
            * (((1.0000000000000000000_f64) + (__intermediate_result_12))
                .powf(-0.50000000000000000000_f64))
            * ((s).asinh())
            * (__intermediate_result_23)))
        * (if (((s).sqrt())
            + (-((__intermediate_result_14).sinh()))
            + ((5.23500000000000_f64) * ((s).recip()))
            + ((12.4000000000000_f64) * ((s).powf(-2.24000000000000_f64)))
            + ((-0.693962526023595_f64) * (s))
            + (-((__intermediate_result_9) * (__intermediate_result_17)))
            + ((__intermediate_result_12)
                * (__intermediate_result_19)
                * (__intermediate_result_23)))
            .abs()
            == 0.0_f64
        {
            (((s).sqrt())
                + (-((__intermediate_result_14).sinh()))
                + ((5.23500000000000_f64) * ((s).recip()))
                + ((12.4000000000000_f64) * ((s).powf(-2.24000000000000_f64)))
                + ((-0.693962526023595_f64) * (s))
                + (-((__intermediate_result_9) * (__intermediate_result_17)))
                + ((__intermediate_result_12)
                    * (__intermediate_result_19)
                    * (__intermediate_result_23)))
        } else {
            (((s).sqrt())
                + (-((__intermediate_result_14).sinh()))
                + ((5.23500000000000_f64) * ((s).recip()))
                + ((12.4000000000000_f64) * ((s).powf(-2.24000000000000_f64)))
                + ((-0.693962526023595_f64) * (s))
                + (-((__intermediate_result_9) * (__intermediate_result_17)))
                + ((__intermediate_result_12)
                    * (__intermediate_result_19)
                    * (__intermediate_result_23)))
                .signum()
        }))
}

/*

* Code generated by Symars. Thank you for using Symars!
  Symars is licensed under MIT licnese.
  Repository: https://github.com/Da1sypetals/Symars

* Computation code is not intended for manual editing.

* If you find an error,
  or if you believe Symars generates incorrect result,
  please raise an issue under our repo with minimal reproducible example.

*/

/*

* Code generated by Symars. Thank you for using Symars!
  Symars is licensed under MIT licnese.
  Repository: https://github.com/Da1sypetals/Symars

* Computation code is not intended for manual editing.

* If you find an error,
  or if you believe Symars generates incorrect result,
  please raise an issue under our repo with minimal reproducible example.

*/

#[inline]
pub fn grad_det3_0_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (((a4) * (a8)) + (-((a5) * (a7))))
}

#[inline]
pub fn grad_det3_1_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (((a5) * (a6)) + (-((a3) * (a8))))
}

#[inline]
pub fn grad_det3_2_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (((a3) * (a7)) + (-((a4) * (a6))))
}

#[inline]
pub fn grad_det3_3_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (((a2) * (a7)) + (-((a1) * (a8))))
}

#[inline]
pub fn grad_det3_4_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (((a0) * (a8)) + (-((a2) * (a6))))
}

#[inline]
pub fn grad_det3_5_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (((a1) * (a6)) + (-((a0) * (a7))))
}

#[inline]
pub fn grad_det3_6_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (((a1) * (a5)) + (-((a2) * (a4))))
}

#[inline]
pub fn grad_det3_7_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (((a2) * (a3)) + (-((a0) * (a5))))
}

#[inline]
pub fn grad_det3_8_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (((a0) * (a4)) + (-((a1) * (a3))))
}

pub fn grad_det3(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> nalgebra::SMatrix<f64, 9, 1> {
    let mut result = nalgebra::SMatrix::zeros();

    result[(0, 0)] = grad_det3_0_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(1, 0)] = grad_det3_1_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(2, 0)] = grad_det3_2_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(3, 0)] = grad_det3_3_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(4, 0)] = grad_det3_4_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(5, 0)] = grad_det3_5_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(6, 0)] = grad_det3_6_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(7, 0)] = grad_det3_7_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(8, 0)] = grad_det3_8_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result
}

#[inline]
pub const fn hess_det_0_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_0_1(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_0_2(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_0_3(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_0_4(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a8
}

#[inline]
pub fn hess_det_0_5(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a7))
}

#[inline]
pub const fn hess_det_0_6(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_0_7(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a5))
}

#[inline]
pub fn hess_det_0_8(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a4
}

#[inline]
pub const fn hess_det_1_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_1_1(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_1_2(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_1_3(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a8))
}

#[inline]
pub const fn hess_det_1_4(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_1_5(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a6
}

#[inline]
pub fn hess_det_1_6(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a5
}

#[inline]
pub const fn hess_det_1_7(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_1_8(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a3))
}

#[inline]
pub const fn hess_det_2_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_2_1(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_2_2(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_2_3(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a7
}

#[inline]
pub fn hess_det_2_4(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a6))
}

#[inline]
pub const fn hess_det_2_5(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_2_6(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a4))
}

#[inline]
pub fn hess_det_2_7(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a3
}

#[inline]
pub const fn hess_det_2_8(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_3_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_3_1(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a8))
}

#[inline]
pub fn hess_det_3_2(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a7
}

#[inline]
pub const fn hess_det_3_3(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_3_4(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_3_5(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_3_6(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_3_7(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a2
}

#[inline]
pub fn hess_det_3_8(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a1))
}

#[inline]
pub fn hess_det_4_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a8
}

#[inline]
pub const fn hess_det_4_1(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_4_2(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a6))
}

#[inline]
pub const fn hess_det_4_3(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_4_4(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_4_5(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_4_6(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a2))
}

#[inline]
pub const fn hess_det_4_7(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_4_8(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a0
}

#[inline]
pub fn hess_det_5_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a7))
}

#[inline]
pub fn hess_det_5_1(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a6
}

#[inline]
pub const fn hess_det_5_2(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_5_3(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_5_4(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_5_5(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_5_6(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a1
}

#[inline]
pub fn hess_det_5_7(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a0))
}

#[inline]
pub const fn hess_det_5_8(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_6_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_6_1(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a5
}

#[inline]
pub fn hess_det_6_2(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a4))
}

#[inline]
pub const fn hess_det_6_3(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_6_4(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a2))
}

#[inline]
pub fn hess_det_6_5(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a1
}

#[inline]
pub const fn hess_det_6_6(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_6_7(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_6_8(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_7_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a5))
}

#[inline]
pub const fn hess_det_7_1(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_7_2(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a3
}

#[inline]
pub fn hess_det_7_3(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a2
}

#[inline]
pub const fn hess_det_7_4(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_7_5(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a0))
}

#[inline]
pub const fn hess_det_7_6(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_7_7(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_7_8(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_8_0(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a4
}

#[inline]
pub fn hess_det_8_1(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a3))
}

#[inline]
pub const fn hess_det_8_2(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det_8_3(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    (-(a1))
}

#[inline]
pub fn hess_det_8_4(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    a0
}

#[inline]
pub const fn hess_det_8_5(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_8_6(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_8_7(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det_8_8(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> f64 {
    0_f64
}

pub fn hess_det3(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
) -> nalgebra::SMatrix<f64, 9, 9> {
    let mut result = nalgebra::SMatrix::zeros();

    result[(0, 0)] = hess_det_0_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(0, 1)] = hess_det_0_1(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(0, 2)] = hess_det_0_2(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(0, 3)] = hess_det_0_3(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(0, 4)] = hess_det_0_4(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(0, 5)] = hess_det_0_5(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(0, 6)] = hess_det_0_6(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(0, 7)] = hess_det_0_7(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(0, 8)] = hess_det_0_8(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(1, 0)] = hess_det_1_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(1, 1)] = hess_det_1_1(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(1, 2)] = hess_det_1_2(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(1, 3)] = hess_det_1_3(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(1, 4)] = hess_det_1_4(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(1, 5)] = hess_det_1_5(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(1, 6)] = hess_det_1_6(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(1, 7)] = hess_det_1_7(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(1, 8)] = hess_det_1_8(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(2, 0)] = hess_det_2_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(2, 1)] = hess_det_2_1(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(2, 2)] = hess_det_2_2(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(2, 3)] = hess_det_2_3(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(2, 4)] = hess_det_2_4(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(2, 5)] = hess_det_2_5(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(2, 6)] = hess_det_2_6(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(2, 7)] = hess_det_2_7(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(2, 8)] = hess_det_2_8(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(3, 0)] = hess_det_3_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(3, 1)] = hess_det_3_1(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(3, 2)] = hess_det_3_2(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(3, 3)] = hess_det_3_3(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(3, 4)] = hess_det_3_4(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(3, 5)] = hess_det_3_5(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(3, 6)] = hess_det_3_6(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(3, 7)] = hess_det_3_7(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(3, 8)] = hess_det_3_8(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(4, 0)] = hess_det_4_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(4, 1)] = hess_det_4_1(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(4, 2)] = hess_det_4_2(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(4, 3)] = hess_det_4_3(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(4, 4)] = hess_det_4_4(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(4, 5)] = hess_det_4_5(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(4, 6)] = hess_det_4_6(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(4, 7)] = hess_det_4_7(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(4, 8)] = hess_det_4_8(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(5, 0)] = hess_det_5_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(5, 1)] = hess_det_5_1(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(5, 2)] = hess_det_5_2(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(5, 3)] = hess_det_5_3(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(5, 4)] = hess_det_5_4(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(5, 5)] = hess_det_5_5(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(5, 6)] = hess_det_5_6(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(5, 7)] = hess_det_5_7(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(5, 8)] = hess_det_5_8(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(6, 0)] = hess_det_6_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(6, 1)] = hess_det_6_1(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(6, 2)] = hess_det_6_2(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(6, 3)] = hess_det_6_3(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(6, 4)] = hess_det_6_4(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(6, 5)] = hess_det_6_5(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(6, 6)] = hess_det_6_6(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(6, 7)] = hess_det_6_7(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(6, 8)] = hess_det_6_8(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(7, 0)] = hess_det_7_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(7, 1)] = hess_det_7_1(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(7, 2)] = hess_det_7_2(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(7, 3)] = hess_det_7_3(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(7, 4)] = hess_det_7_4(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(7, 5)] = hess_det_7_5(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(7, 6)] = hess_det_7_6(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(7, 7)] = hess_det_7_7(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(7, 8)] = hess_det_7_8(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(8, 0)] = hess_det_8_0(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(8, 1)] = hess_det_8_1(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(8, 2)] = hess_det_8_2(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(8, 3)] = hess_det_8_3(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(8, 4)] = hess_det_8_4(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(8, 5)] = hess_det_8_5(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(8, 6)] = hess_det_8_6(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(8, 7)] = hess_det_8_7(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result[(8, 8)] = hess_det_8_8(a0, a1, a2, a3, a4, a5, a6, a7, a8);

    result
}
/*

* Code generated by Symars. Thank you for using Symars!
  Symars is licensed under MIT licnese.
  Repository: https://github.com/Da1sypetals/Symars

* Computation code is not intended for manual editing.

* If you find an error,
  or if you believe Symars generates incorrect result,
  please raise an issue under our repo with minimal reproducible example.

*/

#[inline]
pub fn grad_det4_0_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a15) * (a5))
        + ((a11) * (a13) * (a6))
        + ((a14) * (a7) * (a9))
        + (-((a10) * (a13) * (a7)))
        + (-((a11) * (a14) * (a5)))
        + (-((a15) * (a6) * (a9))))
}

#[inline]
pub fn grad_det4_1_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a12) * (a7))
        + ((a11) * (a14) * (a4))
        + ((a15) * (a6) * (a8))
        + (-((a10) * (a15) * (a4)))
        + (-((a11) * (a12) * (a6)))
        + (-((a14) * (a7) * (a8))))
}

#[inline]
pub fn grad_det4_10_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a15) * (a5))
        + ((a1) * (a12) * (a7))
        + ((a13) * (a3) * (a4))
        + (-((a0) * (a13) * (a7)))
        + (-((a1) * (a15) * (a4)))
        + (-((a12) * (a3) * (a5))))
}

#[inline]
pub fn grad_det4_11_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a13) * (a6))
        + ((a1) * (a14) * (a4))
        + ((a12) * (a2) * (a5))
        + (-((a0) * (a14) * (a5)))
        + (-((a1) * (a12) * (a6)))
        + (-((a13) * (a2) * (a4))))
}

#[inline]
pub fn grad_det4_12_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a10) * (a7))
        + ((a11) * (a2) * (a5))
        + ((a3) * (a6) * (a9))
        + (-((a1) * (a11) * (a6)))
        + (-((a10) * (a3) * (a5)))
        + (-((a2) * (a7) * (a9))))
}

#[inline]
pub fn grad_det4_13_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a11) * (a6))
        + ((a10) * (a3) * (a4))
        + ((a2) * (a7) * (a8))
        + (-((a0) * (a10) * (a7)))
        + (-((a11) * (a2) * (a4)))
        + (-((a3) * (a6) * (a8))))
}

#[inline]
pub fn grad_det4_14_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a7) * (a9))
        + ((a1) * (a11) * (a4))
        + ((a3) * (a5) * (a8))
        + (-((a0) * (a11) * (a5)))
        + (-((a1) * (a7) * (a8)))
        + (-((a3) * (a4) * (a9))))
}

#[inline]
pub fn grad_det4_15_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a10) * (a5))
        + ((a1) * (a6) * (a8))
        + ((a2) * (a4) * (a9))
        + (-((a0) * (a6) * (a9)))
        + (-((a1) * (a10) * (a4)))
        + (-((a2) * (a5) * (a8))))
}

#[inline]
pub fn grad_det4_2_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a12) * (a5))
        + ((a13) * (a7) * (a8))
        + ((a15) * (a4) * (a9))
        + (-((a11) * (a13) * (a4)))
        + (-((a12) * (a7) * (a9)))
        + (-((a15) * (a5) * (a8))))
}

#[inline]
pub fn grad_det4_3_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a13) * (a4))
        + ((a12) * (a6) * (a9))
        + ((a14) * (a5) * (a8))
        + (-((a10) * (a12) * (a5)))
        + (-((a13) * (a6) * (a8)))
        + (-((a14) * (a4) * (a9))))
}

#[inline]
pub fn grad_det4_4_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a11) * (a14))
        + ((a10) * (a13) * (a3))
        + ((a15) * (a2) * (a9))
        + (-((a1) * (a10) * (a15)))
        + (-((a11) * (a13) * (a2)))
        + (-((a14) * (a3) * (a9))))
}

#[inline]
pub fn grad_det4_5_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a10) * (a15))
        + ((a11) * (a12) * (a2))
        + ((a14) * (a3) * (a8))
        + (-((a0) * (a11) * (a14)))
        + (-((a10) * (a12) * (a3)))
        + (-((a15) * (a2) * (a8))))
}

#[inline]
pub fn grad_det4_6_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a11) * (a13))
        + ((a1) * (a15) * (a8))
        + ((a12) * (a3) * (a9))
        + (-((a0) * (a15) * (a9)))
        + (-((a1) * (a11) * (a12)))
        + (-((a13) * (a3) * (a8))))
}

#[inline]
pub fn grad_det4_7_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a14) * (a9))
        + ((a1) * (a10) * (a12))
        + ((a13) * (a2) * (a8))
        + (-((a0) * (a10) * (a13)))
        + (-((a1) * (a14) * (a8)))
        + (-((a12) * (a2) * (a9))))
}

#[inline]
pub fn grad_det4_8_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a15) * (a6))
        + ((a13) * (a2) * (a7))
        + ((a14) * (a3) * (a5))
        + (-((a1) * (a14) * (a7)))
        + (-((a13) * (a3) * (a6)))
        + (-((a15) * (a2) * (a5))))
}

#[inline]
pub fn grad_det4_9_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a14) * (a7))
        + ((a12) * (a3) * (a6))
        + ((a15) * (a2) * (a4))
        + (-((a0) * (a15) * (a6)))
        + (-((a12) * (a2) * (a7)))
        + (-((a14) * (a3) * (a4))))
}

pub fn grad_det4(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
) -> nalgebra::SMatrix<f64, 16, 1> {
    let mut result = nalgebra::SMatrix::zeros();

    result[(0, 0)] = grad_det4_0_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 0)] = grad_det4_1_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 0)] = grad_det4_2_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 0)] = grad_det4_3_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 0)] = grad_det4_4_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 0)] = grad_det4_5_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 0)] = grad_det4_6_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 0)] = grad_det4_7_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 0)] = grad_det4_8_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 0)] = grad_det4_9_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 0)] = grad_det4_10_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 0)] = grad_det4_11_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 0)] = grad_det4_12_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 0)] = grad_det4_13_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 0)] = grad_det4_14_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 0)] = grad_det4_15_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result
}
/*

* Code generated by Symars. Thank you for using Symars!
  Symars is licensed under MIT licnese.
  Repository: https://github.com/Da1sypetals/Symars

* Computation code is not intended for manual editing.

* If you find an error,
  or if you believe Symars generates incorrect result,
  please raise an issue under our repo with minimal reproducible example.

*/

#[inline]
pub const fn hess_det4_0_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_0_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_0_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a15) * (a5)) + (-((a13) * (a7))))
}

#[inline]
pub fn hess_det4_0_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a13) * (a6)) + (-((a14) * (a5))))
}

#[inline]
pub const fn hess_det4_0_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_0_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a6)) + (-((a10) * (a7))))
}

#[inline]
pub fn hess_det4_0_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a7) * (a9)) + (-((a11) * (a5))))
}

#[inline]
pub fn hess_det4_0_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a5)) + (-((a6) * (a9))))
}

#[inline]
pub const fn hess_det4_0_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_0_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_0_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_0_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a15)) + (-((a11) * (a14))))
}

#[inline]
pub fn hess_det4_0_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a13)) + (-((a15) * (a9))))
}

#[inline]
pub fn hess_det4_0_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a14) * (a9)) + (-((a10) * (a13))))
}

#[inline]
pub const fn hess_det4_0_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_0_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a14) * (a7)) + (-((a15) * (a6))))
}

#[inline]
pub const fn hess_det4_1_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_1_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_1_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a12) * (a7)) + (-((a15) * (a4))))
}

#[inline]
pub fn hess_det4_1_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a14) * (a4)) + (-((a12) * (a6))))
}

#[inline]
pub fn hess_det4_1_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a7)) + (-((a11) * (a6))))
}

#[inline]
pub const fn hess_det4_1_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_1_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a4)) + (-((a7) * (a8))))
}

#[inline]
pub fn hess_det4_1_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a6) * (a8)) + (-((a10) * (a4))))
}

#[inline]
pub const fn hess_det4_1_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_1_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_1_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a14)) + (-((a10) * (a15))))
}

#[inline]
pub const fn hess_det4_1_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_1_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a15) * (a8)) + (-((a11) * (a12))))
}

#[inline]
pub fn hess_det4_1_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a12)) + (-((a14) * (a8))))
}

#[inline]
pub fn hess_det4_1_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a15) * (a6)) + (-((a14) * (a7))))
}

#[inline]
pub const fn hess_det4_1_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_10_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a15) * (a5)) + (-((a13) * (a7))))
}

#[inline]
pub fn hess_det4_10_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a12) * (a7)) + (-((a15) * (a4))))
}

#[inline]
pub const fn hess_det4_10_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_10_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_10_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a7)) + (-((a3) * (a5))))
}

#[inline]
pub fn hess_det4_10_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a3) * (a4)) + (-((a0) * (a7))))
}

#[inline]
pub const fn hess_det4_10_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_10_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a5)) + (-((a1) * (a4))))
}

#[inline]
pub const fn hess_det4_10_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_10_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a13) * (a4)) + (-((a12) * (a5))))
}

#[inline]
pub fn hess_det4_10_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a13) * (a3)) + (-((a1) * (a15))))
}

#[inline]
pub fn hess_det4_10_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a15)) + (-((a12) * (a3))))
}

#[inline]
pub const fn hess_det4_10_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_10_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a12)) + (-((a0) * (a13))))
}

#[inline]
pub const fn hess_det4_10_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_10_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_11_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a13) * (a6)) + (-((a14) * (a5))))
}

#[inline]
pub fn hess_det4_11_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a14) * (a4)) + (-((a12) * (a6))))
}

#[inline]
pub const fn hess_det4_11_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_11_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_11_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a2) * (a5)) + (-((a1) * (a6))))
}

#[inline]
pub fn hess_det4_11_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a6)) + (-((a2) * (a4))))
}

#[inline]
pub fn hess_det4_11_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a4)) + (-((a0) * (a5))))
}

#[inline]
pub const fn hess_det4_11_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_11_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a12) * (a5)) + (-((a13) * (a4))))
}

#[inline]
pub const fn hess_det4_11_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_11_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a14)) + (-((a13) * (a2))))
}

#[inline]
pub fn hess_det4_11_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a12) * (a2)) + (-((a0) * (a14))))
}

#[inline]
pub fn hess_det4_11_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a13)) + (-((a1) * (a12))))
}

#[inline]
pub const fn hess_det4_11_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_11_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_11_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_12_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_12_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a7)) + (-((a11) * (a6))))
}

#[inline]
pub fn hess_det4_12_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a7)) + (-((a3) * (a5))))
}

#[inline]
pub fn hess_det4_12_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a2) * (a5)) + (-((a1) * (a6))))
}

#[inline]
pub const fn hess_det4_12_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_12_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_12_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_12_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_12_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a5)) + (-((a7) * (a9))))
}

#[inline]
pub fn hess_det4_12_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a6) * (a9)) + (-((a10) * (a5))))
}

#[inline]
pub const fn hess_det4_12_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_12_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a2)) + (-((a10) * (a3))))
}

#[inline]
pub fn hess_det4_12_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a3) * (a9)) + (-((a1) * (a11))))
}

#[inline]
pub fn hess_det4_12_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a10)) + (-((a2) * (a9))))
}

#[inline]
pub const fn hess_det4_12_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_12_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a3) * (a6)) + (-((a2) * (a7))))
}

#[inline]
pub fn hess_det4_13_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a6)) + (-((a10) * (a7))))
}

#[inline]
pub const fn hess_det4_13_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_13_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a3) * (a4)) + (-((a0) * (a7))))
}

#[inline]
pub fn hess_det4_13_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a6)) + (-((a2) * (a4))))
}

#[inline]
pub const fn hess_det4_13_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_13_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_13_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_13_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_13_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a7) * (a8)) + (-((a11) * (a4))))
}

#[inline]
pub fn hess_det4_13_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a4)) + (-((a6) * (a8))))
}

#[inline]
pub fn hess_det4_13_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a3)) + (-((a11) * (a2))))
}

#[inline]
pub const fn hess_det4_13_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_13_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a11)) + (-((a3) * (a8))))
}

#[inline]
pub fn hess_det4_13_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a2) * (a8)) + (-((a0) * (a10))))
}

#[inline]
pub fn hess_det4_13_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a2) * (a7)) + (-((a3) * (a6))))
}

#[inline]
pub const fn hess_det4_13_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_14_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a7) * (a9)) + (-((a11) * (a5))))
}

#[inline]
pub fn hess_det4_14_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a4)) + (-((a7) * (a8))))
}

#[inline]
pub const fn hess_det4_14_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_14_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a4)) + (-((a0) * (a5))))
}

#[inline]
pub const fn hess_det4_14_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_14_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_14_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_14_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_14_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_14_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a5) * (a8)) + (-((a4) * (a9))))
}

#[inline]
pub fn hess_det4_14_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a11)) + (-((a3) * (a9))))
}

#[inline]
pub fn hess_det4_14_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a3) * (a8)) + (-((a0) * (a11))))
}

#[inline]
pub const fn hess_det4_14_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_14_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a9)) + (-((a1) * (a8))))
}

#[inline]
pub fn hess_det4_14_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a3) * (a5)) + (-((a1) * (a7))))
}

#[inline]
pub fn hess_det4_14_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a7)) + (-((a3) * (a4))))
}

#[inline]
pub fn hess_det4_15_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a5)) + (-((a6) * (a9))))
}

#[inline]
pub fn hess_det4_15_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a6) * (a8)) + (-((a10) * (a4))))
}

#[inline]
pub fn hess_det4_15_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a5)) + (-((a1) * (a4))))
}

#[inline]
pub const fn hess_det4_15_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_15_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_15_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_15_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_15_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_15_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a4) * (a9)) + (-((a5) * (a8))))
}

#[inline]
pub const fn hess_det4_15_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_15_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a2) * (a9)) + (-((a1) * (a10))))
}

#[inline]
pub fn hess_det4_15_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a10)) + (-((a2) * (a8))))
}

#[inline]
pub fn hess_det4_15_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a8)) + (-((a0) * (a9))))
}

#[inline]
pub const fn hess_det4_15_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_15_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a6)) + (-((a2) * (a5))))
}

#[inline]
pub fn hess_det4_15_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a2) * (a4)) + (-((a0) * (a6))))
}

#[inline]
pub const fn hess_det4_2_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_2_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_2_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_2_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a12) * (a5)) + (-((a13) * (a4))))
}

#[inline]
pub fn hess_det4_2_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a5)) + (-((a7) * (a9))))
}

#[inline]
pub fn hess_det4_2_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a7) * (a8)) + (-((a11) * (a4))))
}

#[inline]
pub const fn hess_det4_2_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_2_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a4) * (a9)) + (-((a5) * (a8))))
}

#[inline]
pub const fn hess_det4_2_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_2_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_2_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a15) * (a9)) + (-((a11) * (a13))))
}

#[inline]
pub fn hess_det4_2_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a12)) + (-((a15) * (a8))))
}

#[inline]
pub const fn hess_det4_2_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_2_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a13) * (a8)) + (-((a12) * (a9))))
}

#[inline]
pub fn hess_det4_2_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a13) * (a7)) + (-((a15) * (a5))))
}

#[inline]
pub fn hess_det4_2_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a15) * (a4)) + (-((a12) * (a7))))
}

#[inline]
pub const fn hess_det4_3_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_3_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_3_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a13) * (a4)) + (-((a12) * (a5))))
}

#[inline]
pub const fn hess_det4_3_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_3_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a6) * (a9)) + (-((a10) * (a5))))
}

#[inline]
pub fn hess_det4_3_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a4)) + (-((a6) * (a8))))
}

#[inline]
pub fn hess_det4_3_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a5) * (a8)) + (-((a4) * (a9))))
}

#[inline]
pub const fn hess_det4_3_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_3_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_3_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_3_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a13)) + (-((a14) * (a9))))
}

#[inline]
pub fn hess_det4_3_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a14) * (a8)) + (-((a10) * (a12))))
}

#[inline]
pub fn hess_det4_3_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a12) * (a9)) + (-((a13) * (a8))))
}

#[inline]
pub const fn hess_det4_3_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_3_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a14) * (a5)) + (-((a13) * (a6))))
}

#[inline]
pub fn hess_det4_3_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a12) * (a6)) + (-((a14) * (a4))))
}

#[inline]
pub const fn hess_det4_4_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_4_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a14)) + (-((a10) * (a15))))
}

#[inline]
pub fn hess_det4_4_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a13) * (a3)) + (-((a1) * (a15))))
}

#[inline]
pub fn hess_det4_4_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a14)) + (-((a13) * (a2))))
}

#[inline]
pub const fn hess_det4_4_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_4_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a3)) + (-((a11) * (a2))))
}

#[inline]
pub fn hess_det4_4_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a11)) + (-((a3) * (a9))))
}

#[inline]
pub fn hess_det4_4_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a2) * (a9)) + (-((a1) * (a10))))
}

#[inline]
pub fn hess_det4_4_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a15) * (a9)) + (-((a11) * (a13))))
}

#[inline]
pub fn hess_det4_4_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a13)) + (-((a14) * (a9))))
}

#[inline]
pub const fn hess_det4_4_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_4_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_4_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_4_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_4_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_4_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a15) * (a2)) + (-((a14) * (a3))))
}

#[inline]
pub fn hess_det4_5_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a15)) + (-((a11) * (a14))))
}

#[inline]
pub const fn hess_det4_5_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_5_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a15)) + (-((a12) * (a3))))
}

#[inline]
pub fn hess_det4_5_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a12) * (a2)) + (-((a0) * (a14))))
}

#[inline]
pub fn hess_det4_5_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a2)) + (-((a10) * (a3))))
}

#[inline]
pub const fn hess_det4_5_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_5_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a3) * (a8)) + (-((a0) * (a11))))
}

#[inline]
pub fn hess_det4_5_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a10)) + (-((a2) * (a8))))
}

#[inline]
pub fn hess_det4_5_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a12)) + (-((a15) * (a8))))
}

#[inline]
pub fn hess_det4_5_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a14) * (a8)) + (-((a10) * (a12))))
}

#[inline]
pub const fn hess_det4_5_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_5_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_5_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_5_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_5_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a14) * (a3)) + (-((a15) * (a2))))
}

#[inline]
pub const fn hess_det4_5_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_6_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a11) * (a13)) + (-((a15) * (a9))))
}

#[inline]
pub fn hess_det4_6_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a15) * (a8)) + (-((a11) * (a12))))
}

#[inline]
pub const fn hess_det4_6_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_6_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a13)) + (-((a1) * (a12))))
}

#[inline]
pub fn hess_det4_6_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a3) * (a9)) + (-((a1) * (a11))))
}

#[inline]
pub fn hess_det4_6_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a11)) + (-((a3) * (a8))))
}

#[inline]
pub const fn hess_det4_6_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_6_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a8)) + (-((a0) * (a9))))
}

#[inline]
pub const fn hess_det4_6_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_6_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a12) * (a9)) + (-((a13) * (a8))))
}

#[inline]
pub const fn hess_det4_6_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_6_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_6_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_6_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_6_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a15)) + (-((a13) * (a3))))
}

#[inline]
pub fn hess_det4_6_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a12) * (a3)) + (-((a0) * (a15))))
}

#[inline]
pub fn hess_det4_7_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a14) * (a9)) + (-((a10) * (a13))))
}

#[inline]
pub fn hess_det4_7_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a10) * (a12)) + (-((a14) * (a8))))
}

#[inline]
pub fn hess_det4_7_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a12)) + (-((a0) * (a13))))
}

#[inline]
pub const fn hess_det4_7_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_7_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a10)) + (-((a2) * (a9))))
}

#[inline]
pub fn hess_det4_7_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a2) * (a8)) + (-((a0) * (a10))))
}

#[inline]
pub fn hess_det4_7_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a9)) + (-((a1) * (a8))))
}

#[inline]
pub const fn hess_det4_7_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_7_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a13) * (a8)) + (-((a12) * (a9))))
}

#[inline]
pub const fn hess_det4_7_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_7_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_7_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_7_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_7_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_7_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a13) * (a2)) + (-((a1) * (a14))))
}

#[inline]
pub fn hess_det4_7_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a14)) + (-((a12) * (a2))))
}

#[inline]
pub const fn hess_det4_8_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_8_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a15) * (a6)) + (-((a14) * (a7))))
}

#[inline]
pub const fn hess_det4_8_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_8_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_8_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_8_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a2) * (a7)) + (-((a3) * (a6))))
}

#[inline]
pub fn hess_det4_8_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a3) * (a5)) + (-((a1) * (a7))))
}

#[inline]
pub fn hess_det4_8_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a6)) + (-((a2) * (a5))))
}

#[inline]
pub fn hess_det4_8_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a13) * (a7)) + (-((a15) * (a5))))
}

#[inline]
pub fn hess_det4_8_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a14) * (a5)) + (-((a13) * (a6))))
}

#[inline]
pub const fn hess_det4_8_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_8_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a14) * (a3)) + (-((a15) * (a2))))
}

#[inline]
pub fn hess_det4_8_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a1) * (a15)) + (-((a13) * (a3))))
}

#[inline]
pub fn hess_det4_8_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a13) * (a2)) + (-((a1) * (a14))))
}

#[inline]
pub const fn hess_det4_8_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_8_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_9_0(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a14) * (a7)) + (-((a15) * (a6))))
}

#[inline]
pub const fn hess_det4_9_1(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_9_10(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_9_11(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_9_12(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a3) * (a6)) + (-((a2) * (a7))))
}

#[inline]
pub const fn hess_det4_9_13(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_9_14(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a7)) + (-((a3) * (a4))))
}

#[inline]
pub fn hess_det4_9_15(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a2) * (a4)) + (-((a0) * (a6))))
}

#[inline]
pub fn hess_det4_9_2(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a15) * (a4)) + (-((a12) * (a7))))
}

#[inline]
pub fn hess_det4_9_3(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a12) * (a6)) + (-((a14) * (a4))))
}

#[inline]
pub fn hess_det4_9_4(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a15) * (a2)) + (-((a14) * (a3))))
}

#[inline]
pub const fn hess_det4_9_5(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub fn hess_det4_9_6(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a12) * (a3)) + (-((a0) * (a15))))
}

#[inline]
pub fn hess_det4_9_7(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    (((a0) * (a14)) + (-((a12) * (a2))))
}

#[inline]
pub const fn hess_det4_9_8(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

#[inline]
pub const fn hess_det4_9_9(
    a0: f64,
    a1: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
) -> f64 {
    0_f64
}

pub fn hess_det4(
    a0: f64,
    a1: f64,
    a2: f64,
    a3: f64,
    a4: f64,
    a5: f64,
    a6: f64,
    a7: f64,
    a8: f64,
    a9: f64,
    a10: f64,
    a11: f64,
    a12: f64,
    a13: f64,
    a14: f64,
    a15: f64,
) -> nalgebra::SMatrix<f64, 16, 16> {
    let mut result = nalgebra::SMatrix::zeros();

    result[(0, 0)] = hess_det4_0_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 1)] = hess_det4_0_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 2)] = hess_det4_0_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 3)] = hess_det4_0_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 4)] = hess_det4_0_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 5)] = hess_det4_0_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 6)] = hess_det4_0_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 7)] = hess_det4_0_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 8)] = hess_det4_0_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 9)] = hess_det4_0_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 10)] = hess_det4_0_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 11)] = hess_det4_0_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 12)] = hess_det4_0_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 13)] = hess_det4_0_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 14)] = hess_det4_0_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(0, 15)] = hess_det4_0_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 0)] = hess_det4_1_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 1)] = hess_det4_1_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 2)] = hess_det4_1_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 3)] = hess_det4_1_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 4)] = hess_det4_1_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 5)] = hess_det4_1_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 6)] = hess_det4_1_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 7)] = hess_det4_1_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 8)] = hess_det4_1_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 9)] = hess_det4_1_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 10)] = hess_det4_1_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 11)] = hess_det4_1_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 12)] = hess_det4_1_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 13)] = hess_det4_1_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 14)] = hess_det4_1_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(1, 15)] = hess_det4_1_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 0)] = hess_det4_2_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 1)] = hess_det4_2_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 2)] = hess_det4_2_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 3)] = hess_det4_2_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 4)] = hess_det4_2_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 5)] = hess_det4_2_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 6)] = hess_det4_2_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 7)] = hess_det4_2_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 8)] = hess_det4_2_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 9)] = hess_det4_2_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 10)] = hess_det4_2_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 11)] = hess_det4_2_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 12)] = hess_det4_2_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 13)] = hess_det4_2_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 14)] = hess_det4_2_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(2, 15)] = hess_det4_2_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 0)] = hess_det4_3_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 1)] = hess_det4_3_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 2)] = hess_det4_3_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 3)] = hess_det4_3_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 4)] = hess_det4_3_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 5)] = hess_det4_3_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 6)] = hess_det4_3_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 7)] = hess_det4_3_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 8)] = hess_det4_3_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 9)] = hess_det4_3_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 10)] = hess_det4_3_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 11)] = hess_det4_3_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 12)] = hess_det4_3_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 13)] = hess_det4_3_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 14)] = hess_det4_3_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(3, 15)] = hess_det4_3_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 0)] = hess_det4_4_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 1)] = hess_det4_4_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 2)] = hess_det4_4_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 3)] = hess_det4_4_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 4)] = hess_det4_4_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 5)] = hess_det4_4_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 6)] = hess_det4_4_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 7)] = hess_det4_4_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 8)] = hess_det4_4_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 9)] = hess_det4_4_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 10)] = hess_det4_4_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 11)] = hess_det4_4_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 12)] = hess_det4_4_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 13)] = hess_det4_4_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 14)] = hess_det4_4_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(4, 15)] = hess_det4_4_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 0)] = hess_det4_5_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 1)] = hess_det4_5_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 2)] = hess_det4_5_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 3)] = hess_det4_5_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 4)] = hess_det4_5_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 5)] = hess_det4_5_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 6)] = hess_det4_5_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 7)] = hess_det4_5_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 8)] = hess_det4_5_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 9)] = hess_det4_5_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 10)] = hess_det4_5_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 11)] = hess_det4_5_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 12)] = hess_det4_5_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 13)] = hess_det4_5_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 14)] = hess_det4_5_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(5, 15)] = hess_det4_5_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 0)] = hess_det4_6_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 1)] = hess_det4_6_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 2)] = hess_det4_6_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 3)] = hess_det4_6_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 4)] = hess_det4_6_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 5)] = hess_det4_6_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 6)] = hess_det4_6_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 7)] = hess_det4_6_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 8)] = hess_det4_6_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 9)] = hess_det4_6_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 10)] = hess_det4_6_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 11)] = hess_det4_6_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 12)] = hess_det4_6_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 13)] = hess_det4_6_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 14)] = hess_det4_6_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(6, 15)] = hess_det4_6_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 0)] = hess_det4_7_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 1)] = hess_det4_7_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 2)] = hess_det4_7_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 3)] = hess_det4_7_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 4)] = hess_det4_7_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 5)] = hess_det4_7_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 6)] = hess_det4_7_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 7)] = hess_det4_7_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 8)] = hess_det4_7_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 9)] = hess_det4_7_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 10)] = hess_det4_7_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 11)] = hess_det4_7_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 12)] = hess_det4_7_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 13)] = hess_det4_7_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 14)] = hess_det4_7_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(7, 15)] = hess_det4_7_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 0)] = hess_det4_8_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 1)] = hess_det4_8_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 2)] = hess_det4_8_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 3)] = hess_det4_8_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 4)] = hess_det4_8_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 5)] = hess_det4_8_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 6)] = hess_det4_8_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 7)] = hess_det4_8_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 8)] = hess_det4_8_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 9)] = hess_det4_8_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 10)] = hess_det4_8_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 11)] = hess_det4_8_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 12)] = hess_det4_8_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 13)] = hess_det4_8_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 14)] = hess_det4_8_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(8, 15)] = hess_det4_8_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 0)] = hess_det4_9_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 1)] = hess_det4_9_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 2)] = hess_det4_9_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 3)] = hess_det4_9_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 4)] = hess_det4_9_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 5)] = hess_det4_9_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 6)] = hess_det4_9_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 7)] = hess_det4_9_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 8)] = hess_det4_9_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 9)] = hess_det4_9_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 10)] = hess_det4_9_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 11)] = hess_det4_9_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 12)] = hess_det4_9_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 13)] = hess_det4_9_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 14)] = hess_det4_9_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(9, 15)] = hess_det4_9_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 0)] = hess_det4_10_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 1)] = hess_det4_10_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 2)] = hess_det4_10_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 3)] = hess_det4_10_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 4)] = hess_det4_10_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 5)] = hess_det4_10_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 6)] = hess_det4_10_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 7)] = hess_det4_10_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 8)] = hess_det4_10_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 9)] = hess_det4_10_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 10)] = hess_det4_10_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 11)] = hess_det4_10_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 12)] = hess_det4_10_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 13)] = hess_det4_10_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 14)] = hess_det4_10_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(10, 15)] = hess_det4_10_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 0)] = hess_det4_11_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 1)] = hess_det4_11_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 2)] = hess_det4_11_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 3)] = hess_det4_11_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 4)] = hess_det4_11_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 5)] = hess_det4_11_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 6)] = hess_det4_11_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 7)] = hess_det4_11_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 8)] = hess_det4_11_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 9)] = hess_det4_11_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 10)] = hess_det4_11_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 11)] = hess_det4_11_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 12)] = hess_det4_11_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 13)] = hess_det4_11_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 14)] = hess_det4_11_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(11, 15)] = hess_det4_11_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 0)] = hess_det4_12_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 1)] = hess_det4_12_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 2)] = hess_det4_12_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 3)] = hess_det4_12_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 4)] = hess_det4_12_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 5)] = hess_det4_12_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 6)] = hess_det4_12_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 7)] = hess_det4_12_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 8)] = hess_det4_12_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 9)] = hess_det4_12_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 10)] = hess_det4_12_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 11)] = hess_det4_12_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 12)] = hess_det4_12_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 13)] = hess_det4_12_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 14)] = hess_det4_12_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(12, 15)] = hess_det4_12_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 0)] = hess_det4_13_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 1)] = hess_det4_13_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 2)] = hess_det4_13_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 3)] = hess_det4_13_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 4)] = hess_det4_13_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 5)] = hess_det4_13_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 6)] = hess_det4_13_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 7)] = hess_det4_13_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 8)] = hess_det4_13_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 9)] = hess_det4_13_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 10)] = hess_det4_13_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 11)] = hess_det4_13_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 12)] = hess_det4_13_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 13)] = hess_det4_13_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 14)] = hess_det4_13_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(13, 15)] = hess_det4_13_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 0)] = hess_det4_14_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 1)] = hess_det4_14_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 2)] = hess_det4_14_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 3)] = hess_det4_14_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 4)] = hess_det4_14_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 5)] = hess_det4_14_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 6)] = hess_det4_14_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 7)] = hess_det4_14_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 8)] = hess_det4_14_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 9)] = hess_det4_14_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 10)] = hess_det4_14_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 11)] = hess_det4_14_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 12)] = hess_det4_14_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 13)] = hess_det4_14_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 14)] = hess_det4_14_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(14, 15)] = hess_det4_14_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 0)] = hess_det4_15_0(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 1)] = hess_det4_15_1(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 2)] = hess_det4_15_2(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 3)] = hess_det4_15_3(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 4)] = hess_det4_15_4(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 5)] = hess_det4_15_5(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 6)] = hess_det4_15_6(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 7)] = hess_det4_15_7(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 8)] = hess_det4_15_8(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 9)] = hess_det4_15_9(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 10)] = hess_det4_15_10(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 11)] = hess_det4_15_11(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 12)] = hess_det4_15_12(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 13)] = hess_det4_15_13(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 14)] = hess_det4_15_14(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result[(15, 15)] = hess_det4_15_15(
        a0, a1, a10, a11, a12, a13, a14, a15, a2, a3, a4, a5, a6, a7, a8, a9,
    );

    result
}