#![allow(clippy::all)]
#![allow(non_snake_case)]
#![allow(unused_parens)]
#![allow(clippy::all)]
#![allow(non_snake_case)]
#![allow(unused_parens)]
pub mod generated_bvp_large_superblock_variants {
pub fn fixture_bvp32_residual_t2_chunk_0(args: &[f64], out: &mut [f64]) {
debug_assert!(args.len() >= 64, "expected at least 64 arguments");
debug_assert!(out.len() >= 32, "expected at least 32 output slots");
let t0 = args[1];
let t1 = args[0];
let t2 = 1.00000000000000000e0_f64;
let t3 = t1 - t2;
let t4 = t0 - t3;
let t5 = t4 - t2;
let t6 = -1.00000000000000000e0_f64;
let t7 = t6 * t1;
let t8 = args[2];
let t9 = t7 + t8;
let t10 = t9 - t2;
let t11 = t6 * t0;
let t12 = args[3];
let t13 = t11 + t12;
let t14 = t8 - t0;
let t15 = t13 - t14;
let t16 = 3.00000000000000000e0_f64;
let t17 = t0.powf(t16);
let t18 = t6 * t17;
let t19 = t18 - t8;
let t20 = args[4];
let t21 = t19 + t20;
let t22 = t6 * t12;
let t23 = args[5];
let t24 = t22 + t23;
let t25 = t20 - t12;
let t26 = t24 - t25;
let t27 = t12.powf(t16);
let t28 = t6 * t27;
let t29 = t28 - t20;
let t30 = args[6];
let t31 = t29 + t30;
let t32 = t6 * t23;
let t33 = args[7];
let t34 = t32 + t33;
let t35 = t30 - t23;
let t36 = t34 - t35;
let t37 = t23.powf(t16);
let t38 = t6 * t37;
let t39 = t38 - t30;
let t40 = args[8];
let t41 = t39 + t40;
let t42 = t6 * t33;
let t43 = args[9];
let t44 = t42 + t43;
let t45 = t40 - t33;
let t46 = t44 - t45;
let t47 = t33.powf(t16);
let t48 = t6 * t47;
let t49 = t48 - t40;
let t50 = args[10];
let t51 = t49 + t50;
let t52 = t6 * t43;
let t53 = args[11];
let t54 = t52 + t53;
let t55 = t50 - t43;
let t56 = t54 - t55;
let t57 = t43.powf(t16);
let t58 = t6 * t57;
let t59 = t58 - t50;
let t60 = args[12];
let t61 = t59 + t60;
let t62 = t6 * t53;
let t63 = args[13];
let t64 = t62 + t63;
let t65 = t60 - t53;
let t66 = t64 - t65;
let t67 = t53.powf(t16);
let t68 = t6 * t67;
let t69 = t68 - t60;
let t70 = args[14];
let t71 = t69 + t70;
let t72 = t6 * t63;
let t73 = args[15];
let t74 = t72 + t73;
let t75 = t70 - t63;
let t76 = t74 - t75;
let t77 = t63.powf(t16);
let t78 = t6 * t77;
let t79 = t78 - t70;
let t80 = args[16];
let t81 = t79 + t80;
let t82 = t6 * t73;
let t83 = args[17];
let t84 = t82 + t83;
let t85 = t80 - t73;
let t86 = t84 - t85;
let t87 = t73.powf(t16);
let t88 = t6 * t87;
let t89 = t88 - t80;
let t90 = args[18];
let t91 = t89 + t90;
let t92 = args[19];
let t93 = t92 - t83;
let t94 = t90 - t83;
let t95 = t93 - t94;
let t96 = t83.powf(t16);
let t97 = t6 * t96;
let t98 = args[20];
let t99 = t97 + t98;
let t100 = t99 - t90;
let t101 = t6 * t92;
let t102 = args[21];
let t103 = t101 + t102;
let t104 = t98 - t92;
let t105 = t103 - t104;
let t106 = t92.powf(t16);
let t107 = t6 * t106;
let t108 = t107 - t98;
let t109 = args[22];
let t110 = t108 + t109;
let t111 = t6 * t102;
let t112 = args[23];
let t113 = t111 + t112;
let t114 = t109 - t102;
let t115 = t113 - t114;
let t116 = t102.powf(t16);
let t117 = t6 * t116;
let t118 = t117 - t109;
let t119 = args[24];
let t120 = t118 + t119;
let t121 = t6 * t112;
let t122 = args[25];
let t123 = t121 + t122;
let t124 = t119 - t112;
let t125 = t123 - t124;
let t126 = t112.powf(t16);
let t127 = t6 * t126;
let t128 = t127 - t119;
let t129 = args[26];
let t130 = t128 + t129;
let t131 = t6 * t122;
let t132 = args[27];
let t133 = t131 + t132;
let t134 = t129 - t122;
let t135 = t133 - t134;
let t136 = t122.powf(t16);
let t137 = t6 * t136;
let t138 = t137 - t129;
let t139 = args[28];
let t140 = t138 + t139;
let t141 = t6 * t132;
let t142 = args[29];
let t143 = t141 + t142;
let t144 = t139 - t132;
let t145 = t143 - t144;
let t146 = t132.powf(t16);
let t147 = t6 * t146;
let t148 = t147 - t139;
let t149 = args[30];
let t150 = t148 + t149;
let t151 = t6 * t142;
let t152 = args[31];
let t153 = t151 + t152;
let t154 = t149 - t142;
let t155 = t153 - t154;
let t156 = t142.powf(t16);
let t157 = t6 * t156;
let t158 = t157 - t149;
let t159 = args[32];
let t160 = t158 + t159;
out[0] = t5;
out[1] = t10;
out[2] = t15;
out[3] = t21;
out[4] = t26;
out[5] = t31;
out[6] = t36;
out[7] = t41;
out[8] = t46;
out[9] = t51;
out[10] = t56;
out[11] = t61;
out[12] = t66;
out[13] = t71;
out[14] = t76;
out[15] = t81;
out[16] = t86;
out[17] = t91;
out[18] = t95;
out[19] = t100;
out[20] = t105;
out[21] = t110;
out[22] = t115;
out[23] = t120;
out[24] = t125;
out[25] = t130;
out[26] = t135;
out[27] = t140;
out[28] = t145;
out[29] = t150;
out[30] = t155;
out[31] = t160;
}
pub fn fixture_bvp32_residual_t2_chunk_1(args: &[f64], out: &mut [f64]) {
debug_assert!(args.len() >= 64, "expected at least 64 arguments");
debug_assert!(out.len() >= 32, "expected at least 32 output slots");
let t0 = -1.00000000000000000e0_f64;
let t1 = args[31];
let t2 = t0 * t1;
let t3 = args[33];
let t4 = t2 + t3;
let t5 = args[32];
let t6 = t5 - t1;
let t7 = t4 - t6;
let t8 = 3.00000000000000000e0_f64;
let t9 = t1.powf(t8);
let t10 = t0 * t9;
let t11 = t10 - t5;
let t12 = args[34];
let t13 = t11 + t12;
let t14 = t0 * t3;
let t15 = args[35];
let t16 = t14 + t15;
let t17 = t12 - t3;
let t18 = t16 - t17;
let t19 = t3.powf(t8);
let t20 = t0 * t19;
let t21 = t20 - t12;
let t22 = args[36];
let t23 = t21 + t22;
let t24 = t0 * t15;
let t25 = args[37];
let t26 = t24 + t25;
let t27 = t22 - t15;
let t28 = t26 - t27;
let t29 = t15.powf(t8);
let t30 = t0 * t29;
let t31 = t30 - t22;
let t32 = args[38];
let t33 = t31 + t32;
let t34 = t0 * t25;
let t35 = args[39];
let t36 = t34 + t35;
let t37 = t32 - t25;
let t38 = t36 - t37;
let t39 = t25.powf(t8);
let t40 = t0 * t39;
let t41 = t40 - t32;
let t42 = args[40];
let t43 = t41 + t42;
let t44 = t0 * t35;
let t45 = args[41];
let t46 = t44 + t45;
let t47 = t42 - t35;
let t48 = t46 - t47;
let t49 = t35.powf(t8);
let t50 = t0 * t49;
let t51 = t50 - t42;
let t52 = args[42];
let t53 = t51 + t52;
let t54 = t0 * t45;
let t55 = args[43];
let t56 = t54 + t55;
let t57 = t52 - t45;
let t58 = t56 - t57;
let t59 = t45.powf(t8);
let t60 = t0 * t59;
let t61 = t60 - t52;
let t62 = args[44];
let t63 = t61 + t62;
let t64 = t0 * t55;
let t65 = args[45];
let t66 = t64 + t65;
let t67 = t62 - t55;
let t68 = t66 - t67;
let t69 = t55.powf(t8);
let t70 = t0 * t69;
let t71 = t70 - t62;
let t72 = args[46];
let t73 = t71 + t72;
let t74 = t0 * t65;
let t75 = args[47];
let t76 = t74 + t75;
let t77 = t72 - t65;
let t78 = t76 - t77;
let t79 = t65.powf(t8);
let t80 = t0 * t79;
let t81 = t80 - t72;
let t82 = args[48];
let t83 = t81 + t82;
let t84 = t0 * t75;
let t85 = args[49];
let t86 = t84 + t85;
let t87 = t82 - t75;
let t88 = t86 - t87;
let t89 = t75.powf(t8);
let t90 = t0 * t89;
let t91 = t90 - t82;
let t92 = args[50];
let t93 = t91 + t92;
let t94 = t0 * t85;
let t95 = args[51];
let t96 = t94 + t95;
let t97 = t92 - t85;
let t98 = t96 - t97;
let t99 = t85.powf(t8);
let t100 = t0 * t99;
let t101 = t100 - t92;
let t102 = args[52];
let t103 = t101 + t102;
let t104 = t0 * t95;
let t105 = args[53];
let t106 = t104 + t105;
let t107 = t102 - t95;
let t108 = t106 - t107;
let t109 = t95.powf(t8);
let t110 = t0 * t109;
let t111 = t110 - t102;
let t112 = args[54];
let t113 = t111 + t112;
let t114 = t0 * t105;
let t115 = args[55];
let t116 = t114 + t115;
let t117 = t112 - t105;
let t118 = t116 - t117;
let t119 = t105.powf(t8);
let t120 = t0 * t119;
let t121 = t120 - t112;
let t122 = args[56];
let t123 = t121 + t122;
let t124 = t0 * t115;
let t125 = args[57];
let t126 = t124 + t125;
let t127 = t122 - t115;
let t128 = t126 - t127;
let t129 = t115.powf(t8);
let t130 = t0 * t129;
let t131 = t130 - t122;
let t132 = args[58];
let t133 = t131 + t132;
let t134 = t0 * t125;
let t135 = args[59];
let t136 = t134 + t135;
let t137 = t132 - t125;
let t138 = t136 - t137;
let t139 = t125.powf(t8);
let t140 = t0 * t139;
let t141 = t140 - t132;
let t142 = args[60];
let t143 = t141 + t142;
let t144 = t0 * t135;
let t145 = args[61];
let t146 = t144 + t145;
let t147 = t142 - t135;
let t148 = t146 - t147;
let t149 = t135.powf(t8);
let t150 = t0 * t149;
let t151 = t150 - t142;
let t152 = args[62];
let t153 = t151 + t152;
let t154 = t0 * t145;
let t155 = args[63];
let t156 = t154 + t155;
let t157 = t152 - t145;
let t158 = t156 - t157;
let t159 = t145.powf(t8);
let t160 = t0 * t159;
let t161 = t160 - t152;
let t162 = 1.00000000000000000e0_f64;
let t163 = t161 + t162;
out[0] = t7;
out[1] = t13;
out[2] = t18;
out[3] = t23;
out[4] = t28;
out[5] = t33;
out[6] = t38;
out[7] = t43;
out[8] = t48;
out[9] = t53;
out[10] = t58;
out[11] = t63;
out[12] = t68;
out[13] = t73;
out[14] = t78;
out[15] = t83;
out[16] = t88;
out[17] = t93;
out[18] = t98;
out[19] = t103;
out[20] = t108;
out[21] = t113;
out[22] = t118;
out[23] = t123;
out[24] = t128;
out[25] = t133;
out[26] = t138;
out[27] = t143;
out[28] = t148;
out[29] = t153;
out[30] = t158;
out[31] = t163;
}
pub fn fixture_bvp32_sparse_t2_chunk_0(args: &[f64], out: &mut [f64]) {
debug_assert!(args.len() >= 64, "expected at least 64 arguments");
debug_assert!(out.len() >= 79, "expected at least 79 output slots");
let t0 = -1.00000000000000000e0_f64;
let t1 = 1.00000000000000000e0_f64;
let t2 = -3.00000000000000000e0_f64;
let t3 = args[1];
let t4 = 2.00000000000000000e0_f64;
let t5 = t3.powf(t4);
let t6 = t2 * t5;
let t7 = args[3];
let t8 = t7.powf(t4);
let t9 = t2 * t8;
let t10 = args[5];
let t11 = t10.powf(t4);
let t12 = t2 * t11;
let t13 = args[7];
let t14 = t13.powf(t4);
let t15 = t2 * t14;
let t16 = args[9];
let t17 = t16.powf(t4);
let t18 = t2 * t17;
let t19 = args[11];
let t20 = t19.powf(t4);
let t21 = t2 * t20;
let t22 = args[13];
let t23 = t22.powf(t4);
let t24 = t2 * t23;
let t25 = args[15];
let t26 = t25.powf(t4);
let t27 = t2 * t26;
let t28 = args[17];
let t29 = t28.powf(t4);
let t30 = t2 * t29;
let t31 = args[19];
let t32 = t31.powf(t4);
let t33 = t2 * t32;
let t34 = args[21];
let t35 = t34.powf(t4);
let t36 = t2 * t35;
let t37 = args[23];
let t38 = t37.powf(t4);
let t39 = t2 * t38;
let t40 = args[25];
let t41 = t40.powf(t4);
let t42 = t2 * t41;
let t43 = args[27];
let t44 = t43.powf(t4);
let t45 = t2 * t44;
let t46 = args[29];
let t47 = t46.powf(t4);
let t48 = t2 * t47;
out[0] = t0;
out[1] = t1;
out[2] = t0;
out[3] = t1;
out[4] = t0;
out[5] = t1;
out[6] = t6;
out[7] = t0;
out[8] = t1;
out[9] = t0;
out[10] = t1;
out[11] = t9;
out[12] = t0;
out[13] = t1;
out[14] = t0;
out[15] = t1;
out[16] = t12;
out[17] = t0;
out[18] = t1;
out[19] = t0;
out[20] = t1;
out[21] = t15;
out[22] = t0;
out[23] = t1;
out[24] = t0;
out[25] = t1;
out[26] = t18;
out[27] = t0;
out[28] = t1;
out[29] = t0;
out[30] = t1;
out[31] = t21;
out[32] = t0;
out[33] = t1;
out[34] = t0;
out[35] = t1;
out[36] = t24;
out[37] = t0;
out[38] = t1;
out[39] = t0;
out[40] = t1;
out[41] = t27;
out[42] = t0;
out[43] = t1;
out[44] = t0;
out[45] = t1;
out[46] = t30;
out[47] = t0;
out[48] = t1;
out[49] = t0;
out[50] = t1;
out[51] = t33;
out[52] = t0;
out[53] = t1;
out[54] = t0;
out[55] = t1;
out[56] = t36;
out[57] = t0;
out[58] = t1;
out[59] = t0;
out[60] = t1;
out[61] = t39;
out[62] = t0;
out[63] = t1;
out[64] = t0;
out[65] = t1;
out[66] = t42;
out[67] = t0;
out[68] = t1;
out[69] = t0;
out[70] = t1;
out[71] = t45;
out[72] = t0;
out[73] = t1;
out[74] = t0;
out[75] = t1;
out[76] = t48;
out[77] = t0;
out[78] = t1;
}
pub fn fixture_bvp32_sparse_t2_chunk_1(args: &[f64], out: &mut [f64]) {
debug_assert!(args.len() >= 64, "expected at least 64 arguments");
debug_assert!(out.len() >= 79, "expected at least 79 output slots");
let t0 = -1.00000000000000000e0_f64;
let t1 = 1.00000000000000000e0_f64;
let t2 = -3.00000000000000000e0_f64;
let t3 = args[31];
let t4 = 2.00000000000000000e0_f64;
let t5 = t3.powf(t4);
let t6 = t2 * t5;
let t7 = args[33];
let t8 = t7.powf(t4);
let t9 = t2 * t8;
let t10 = args[35];
let t11 = t10.powf(t4);
let t12 = t2 * t11;
let t13 = args[37];
let t14 = t13.powf(t4);
let t15 = t2 * t14;
let t16 = args[39];
let t17 = t16.powf(t4);
let t18 = t2 * t17;
let t19 = args[41];
let t20 = t19.powf(t4);
let t21 = t2 * t20;
let t22 = args[43];
let t23 = t22.powf(t4);
let t24 = t2 * t23;
let t25 = args[45];
let t26 = t25.powf(t4);
let t27 = t2 * t26;
let t28 = args[47];
let t29 = t28.powf(t4);
let t30 = t2 * t29;
let t31 = args[49];
let t32 = t31.powf(t4);
let t33 = t2 * t32;
let t34 = args[51];
let t35 = t34.powf(t4);
let t36 = t2 * t35;
let t37 = args[53];
let t38 = t37.powf(t4);
let t39 = t2 * t38;
let t40 = args[55];
let t41 = t40.powf(t4);
let t42 = t2 * t41;
let t43 = args[57];
let t44 = t43.powf(t4);
let t45 = t2 * t44;
let t46 = args[59];
let t47 = t46.powf(t4);
let t48 = t2 * t47;
let t49 = args[61];
let t50 = t49.powf(t4);
let t51 = t2 * t50;
out[0] = t0;
out[1] = t1;
out[2] = t6;
out[3] = t0;
out[4] = t1;
out[5] = t0;
out[6] = t1;
out[7] = t9;
out[8] = t0;
out[9] = t1;
out[10] = t0;
out[11] = t1;
out[12] = t12;
out[13] = t0;
out[14] = t1;
out[15] = t0;
out[16] = t1;
out[17] = t15;
out[18] = t0;
out[19] = t1;
out[20] = t0;
out[21] = t1;
out[22] = t18;
out[23] = t0;
out[24] = t1;
out[25] = t0;
out[26] = t1;
out[27] = t21;
out[28] = t0;
out[29] = t1;
out[30] = t0;
out[31] = t1;
out[32] = t24;
out[33] = t0;
out[34] = t1;
out[35] = t0;
out[36] = t1;
out[37] = t27;
out[38] = t0;
out[39] = t1;
out[40] = t0;
out[41] = t1;
out[42] = t30;
out[43] = t0;
out[44] = t1;
out[45] = t0;
out[46] = t1;
out[47] = t33;
out[48] = t0;
out[49] = t1;
out[50] = t0;
out[51] = t1;
out[52] = t36;
out[53] = t0;
out[54] = t1;
out[55] = t0;
out[56] = t1;
out[57] = t39;
out[58] = t0;
out[59] = t1;
out[60] = t0;
out[61] = t1;
out[62] = t42;
out[63] = t0;
out[64] = t1;
out[65] = t0;
out[66] = t1;
out[67] = t45;
out[68] = t0;
out[69] = t1;
out[70] = t0;
out[71] = t1;
out[72] = t48;
out[73] = t0;
out[74] = t1;
out[75] = t0;
out[76] = t1;
out[77] = t51;
out[78] = t0;
}
}
pub mod generated_bvp_large_superblock_variant_bindings {
use super::generated_bvp_large_superblock_variants;
pub const N_STEPS: usize = 32;
pub const RESIDUAL_T2: [fn(&[f64], &mut [f64]); 2] = [
generated_bvp_large_superblock_variants::fixture_bvp32_residual_t2_chunk_0,
generated_bvp_large_superblock_variants::fixture_bvp32_residual_t2_chunk_1,
];
pub const SPARSE_T2: [fn(&[f64], &mut [f64]); 2] = [
generated_bvp_large_superblock_variants::fixture_bvp32_sparse_t2_chunk_0,
generated_bvp_large_superblock_variants::fixture_bvp32_sparse_t2_chunk_1,
];
}