#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ mathModel(double *, double *, double, double, double, double,
                             double **, double **, double **, double **,
                             double **, double **, double **, double **, double,
                             double, double, double, double, double, double,
                             double);
int /*<<< orphan*/ printf(char *, ...);
void ode1(double mass, double specificConsumption, double wingspan,
          double surface, double chord, double Jx, double Jy, double Jz,
          double Jxz, double dt, int n, double steadyStateCoefficients[][126],
          double YForceDerivatives[][126], double ZForceDerivatives[][126],
          double RollingMomentDerivatives[][126],
          double PitchingMomentDerivatives[][126],
          double YawingMomentDerivatives[][126],
          double ControlForceDerivatives[][126],
          double ControlMomentDerivatives[][126], double Y[][12], double y0[],
          double deTrim, double da, double dr, double T, double command[]) {
  int i;
  int j;
  double dy[12] = {0};
  double t = 0;
  double de;
  int dots = 0;
  double initialMass = mass;
  for (i = 0; i < 12; i++) {
    Y[0][i] = y0[i];
  }
  for (j = 1; j < n; j++) {
    de = deTrim + command[j];
    mathModel(dy, Y[j - 1], mass, surface, wingspan, chord,
              steadyStateCoefficients, YForceDerivatives, ZForceDerivatives,
              RollingMomentDerivatives, PitchingMomentDerivatives,
              YawingMomentDerivatives, ControlForceDerivatives,
              ControlMomentDerivatives, Jx, Jy, Jz, Jxz, de, da, dr, T);
    for (i = 0; i < 12; i++) {
      Y[j][i] = Y[j - 1][i] + dt * dy[i];
    }
    t = t + dt;
    if (dots == 100) {
      printf(".");
      dots = 0;
    }
    dots++;
    mass = mass - dt * specificConsumption;
  }
  printf("\nFinal mass is: %lg\n", mass);
  printf("Mass variation is: %lg\n", initialMass - mass);
}


x86 assembly (clang, -O0):
<ode1>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x138,%rsp
mov    0x68(%rbp),%rax
movsd  0x60(%rbp),%xmm8
movsd  0x58(%rbp),%xmm8
movsd  0x50(%rbp),%xmm8
movsd  0x48(%rbp),%xmm8
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
movsd  0x18(%rbp),%xmm8
movsd  0x10(%rbp),%xmm8
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
movsd  %xmm3,-0x28(%rbp)
movsd  %xmm4,-0x30(%rbp)
movsd  %xmm5,-0x38(%rbp)
movsd  %xmm6,-0x40(%rbp)
movsd  %xmm7,-0x48(%rbp)
mov    %edi,-0x4c(%rbp)
mov    %rsi,-0x58(%rbp)
mov    %rdx,-0x60(%rbp)
mov    %rcx,-0x68(%rbp)
mov    %r8,-0x70(%rbp)
mov    %r9,-0x78(%rbp)
lea    -0xe0(%rbp),%rdi
xor    %esi,%esi
mov    $0x60,%edx
call   1040 <memset@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0xf4(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movl   $0x0,-0x7c(%rbp)
cmpl   $0xc,-0x7c(%rbp)
jge    1225 <ode1+0xf5>
mov    0x40(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    11f3 <ode1+0xc3>
movl   $0x1,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    13fb <ode1+0x2cb>
movsd  0x48(%rbp),%xmm0
mov    0x68(%rbp),%rax
movslq -0x80(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
lea    -0xe0(%rbp),%rdi
mov    0x38(%rbp),%rsi
mov    -0x80(%rbp),%eax
sub    $0x1,%eax
cltq
imul   $0x60,%rax,%rax
add    %rax,%rsi
movsd  -0x10(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm3
mov    -0x58(%rbp),%rdx
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%r8
mov    -0x70(%rbp),%r9
mov    -0x78(%rbp),%rbx
mov    0x20(%rbp),%r11
mov    0x28(%rbp),%r10
mov    0x30(%rbp),%rax
movsd  -0x38(%rbp),%xmm4
movsd  -0x40(%rbp),%xmm5
movsd  -0x48(%rbp),%xmm6
movsd  0x10(%rbp),%xmm7
movsd  -0xf0(%rbp),%xmm11
ff ff
movsd  0x50(%rbp),%xmm10
movsd  0x58(%rbp),%xmm9
movsd  0x60(%rbp),%xmm8
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
movsd  %xmm11,0x20(%rsp)
movsd  %xmm10,0x28(%rsp)
movsd  %xmm9,0x30(%rsp)
movsd  %xmm8,0x38(%rsp)
call   1050 <mathModel@plt>
movl   $0x0,-0x7c(%rbp)
cmpl   $0xc,-0x7c(%rbp)
jge    1371 <ode1+0x241>
mov    0x38(%rbp),%rax
mov    -0x80(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x60,%rcx,%rcx
add    %rcx,%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x18(%rbp),%xmm0
movslq -0x7c(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movslq -0x80(%rbp),%rcx
imul   $0x60,%rcx,%rcx
add    %rcx,%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    130a <ode1+0x1da>
movsd  -0xe8(%rbp),%xmm0
ff
addsd  0x18(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
cmpl   $0x64,-0xf4(%rbp)
jne    13ab <ode1+0x27b>
lea    0xc66(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xf4(%rbp)
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
movsd  -0x10(%rbp),%xmm1
movsd  0x18(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    122c <ode1+0xfc>
movsd  -0x10(%rbp),%xmm0
lea    0xbfb(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  -0x100(%rbp),%xmm0
ff
subsd  -0x10(%rbp),%xmm0
lea    0xbf5(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
add    $0x138,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<ode1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r9,0x98(%rsp)
mov    %r8,0x90(%rsp)
mov    %rcx,0x88(%rsp)
movsd  %xmm7,0x80(%rsp)
movsd  %xmm6,0x78(%rsp)
movsd  %xmm5,0x70(%rsp)
movsd  %xmm4,0x68(%rsp)
movsd  %xmm3,0x60(%rsp)
movsd  %xmm2,0x58(%rsp)
movapd %xmm0,%xmm2
mov    0x188(%rsp),%rbp
mov    0x190(%rsp),%rax
xorpd  %xmm0,%xmm0
movapd %xmm0,0xf0(%rsp)
movapd %xmm0,0xe0(%rsp)
movapd %xmm0,0xd0(%rsp)
movapd %xmm0,0xc0(%rsp)
movapd %xmm0,0xb0(%rsp)
movapd %xmm0,0xa0(%rsp)
movsd  (%rax),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rbp)
movsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rbp)
movsd  0x18(%rax),%xmm0
movsd  %xmm0,0x18(%rbp)
movsd  0x20(%rax),%xmm0
movsd  %xmm0,0x20(%rbp)
movsd  0x28(%rax),%xmm0
movsd  %xmm0,0x28(%rbp)
movsd  0x30(%rax),%xmm0
movsd  %xmm0,0x30(%rbp)
movsd  0x38(%rax),%xmm0
movsd  %xmm0,0x38(%rbp)
movsd  0x40(%rax),%xmm0
movsd  %xmm0,0x40(%rbp)
movsd  0x48(%rax),%xmm0
movsd  %xmm0,0x48(%rbp)
movsd  0x50(%rax),%xmm0
movsd  %xmm0,0x50(%rbp)
movsd  0x58(%rax),%xmm0
movsd  %xmm0,0x58(%rbp)
movsd  %xmm2,0x50(%rsp)
cmp    $0x2,%edi
jl     1474 <ode1+0x344>
mov    %rdx,%r13
mov    %rsi,%rbx
movsd  0x168(%rsp),%xmm0
movapd 0xd95(%rip),%xmm2
xorpd  %xmm0,%xmm2
mov    %edi,%r14d
unpcklpd %xmm0,%xmm0
movapd %xmm0,0x110(%rsp)
xor    %r12d,%r12d
mov    $0x1,%r15d
mulsd  %xmm1,%xmm2
movapd %xmm2,0x100(%rsp)
movsd  0x50(%rsp),%xmm2
jmp    12c4 <ode1+0x194>
nopl   (%rax)
add    $0x1,%r12d
movsd  0x48(%rsp),%xmm2
addsd  0x100(%rsp),%xmm2
add    $0x1,%r15
add    $0x60,%rbp
cmp    %r15,%r14
je     1474 <ode1+0x344>
movsd  %xmm2,0x48(%rsp)
mov    0x1b8(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
addsd  0x198(%rsp),%xmm0
movsd  0x1b0(%rsp),%xmm1
movsd  %xmm1,0x38(%rsp)
movsd  0x1a8(%rsp),%xmm1
movsd  %xmm1,0x30(%rsp)
movsd  0x1a0(%rsp),%xmm1
movsd  %xmm1,0x28(%rsp)
movsd  %xmm0,0x20(%rsp)
mov    0x180(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    0x178(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0x170(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    0x98(%rsp),%rax
mov    %rax,(%rsp)
lea    0xa0(%rsp),%rdi
mov    %rbp,%rsi
movapd %xmm2,%xmm0
movsd  0x60(%rsp),%xmm1
movsd  0x58(%rsp),%xmm2
movsd  0x68(%rsp),%xmm3
mov    %rbx,%rdx
mov    %r13,%rcx
mov    0x88(%rsp),%r8
mov    0x90(%rsp),%r9
movsd  0x70(%rsp),%xmm4
movsd  0x78(%rsp),%xmm5
movsd  0x80(%rsp),%xmm6
movsd  0x160(%rsp),%xmm7
call   1050 <mathModel@plt>
movapd 0xa0(%rsp),%xmm0
movapd 0x110(%rsp),%xmm4
mulpd  %xmm4,%xmm0
movupd 0x0(%rbp),%xmm1
addpd  %xmm0,%xmm1
movupd 0x10(%rbp),%xmm0
movupd 0x20(%rbp),%xmm2
movupd 0x30(%rbp),%xmm3
movupd %xmm1,0x60(%rbp)
movapd 0xb0(%rsp),%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,0x70(%rbp)
movapd 0xc0(%rsp),%xmm0
mulpd  %xmm4,%xmm0
addpd  %xmm2,%xmm0
movupd %xmm0,0x80(%rbp)
movapd 0xd0(%rsp),%xmm0
mulpd  %xmm4,%xmm0
addpd  %xmm3,%xmm0
movupd %xmm0,0x90(%rbp)
movupd 0x40(%rbp),%xmm0
movapd 0xe0(%rsp),%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,0xa0(%rbp)
movupd 0x50(%rbp),%xmm0
movapd 0xf0(%rsp),%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,0xb0(%rbp)
cmp    $0x64,%r12d
jne    12a0 <ode1+0x170>
mov    $0x2e,%edi
call   1030 <putchar@plt>
xor    %r12d,%r12d
jmp    12a0 <ode1+0x170>
movsd  %xmm2,0x48(%rsp)
lea    0xb8f(%rip),%rdi
movapd %xmm2,%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
movsd  0x50(%rsp),%xmm0
subsd  0x48(%rsp),%xmm0
lea    0xb86(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [2 x i8] c".\00"
@.str.1 = [21 x i8] c"\0AFinal mass is: %lg\0A\00"
@.str.2 = [24 x i8] c"Mass variation is: %lg\0A\00"
define void @ode1(double %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, double %8, double %9, i32 %10, [126 x double]* %11, [126 x double]* %12, [126 x double]* %13, [126 x double]* %14, [126 x double]* %15, [126 x double]* %16, [126 x double]* %17, [126 x double]* %18, [12 x double]* %19, double* %20, double %21, double %22, double %23, double %24, double* %25) {
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca i32
%38 = alloca [126 x double]*
%39 = alloca [126 x double]*
%40 = alloca [126 x double]*
%41 = alloca [126 x double]*
%42 = alloca [126 x double]*
%43 = alloca [126 x double]*
%44 = alloca [126 x double]*
%45 = alloca [126 x double]*
%46 = alloca [12 x double]*
%47 = alloca double*
%48 = alloca double
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double*
%53 = alloca i32
%54 = alloca i32
%55 = alloca [12 x double]
%56 = alloca double
%57 = alloca double
%58 = alloca i32
%59 = alloca double
store double %0, double* %27
store double %1, double* %28
store double %2, double* %29
store double %3, double* %30
store double %4, double* %31
store double %5, double* %32
store double %6, double* %33
store double %7, double* %34
store double %8, double* %35
store double %9, double* %36
store i32 %10, i32* %37
store [126 x double]* %11, [126 x double]** %38
store [126 x double]* %12, [126 x double]** %39
store [126 x double]* %13, [126 x double]** %40
store [126 x double]* %14, [126 x double]** %41
store [126 x double]* %15, [126 x double]** %42
store [126 x double]* %16, [126 x double]** %43
store [126 x double]* %17, [126 x double]** %44
store [126 x double]* %18, [126 x double]** %45
store [12 x double]* %19, [12 x double]** %46
store double* %20, double** %47
store double %21, double* %48
store double %22, double* %49
store double %23, double* %50
store double %24, double* %51
store double* %25, double** %52
%60 = bitcast [12 x double]* %55 to i8*
store double 0.000000e+00, double* %56
store i32 0, i32* %58
%61 = load double, double* %27
store double %61, double* %59
store i32 0, i32* %53
br label %62
62: ; preds = %76, %26
%63 = load i32, i32* %53
%64 = icmp slt i32 %63, 12
br i1 %64, label %65, label %79
65: ; preds = %62
%66 = load double*, double** %47
%67 = load i32, i32* %53
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %66, i64 %68
%70 = load double, double* %69
%71 = load [12 x double]*, [12 x double]** %46
%72 = getelementptr inbounds [12 x double], [12 x double]* %71, i64 0
%73 = load i32, i32* %53
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [12 x double], [12 x double]* %72, i64 0, i64 %74
store double %70, double* %75
br label %76
76: ; preds = %65
%77 = load i32, i32* %53
%78 = add nsw i32 %77, 1
store i32 %78, i32* %53
br label %62
79: ; preds = %62
store i32 1, i32* %54
br label %80
80: ; preds = %173, %79
%81 = load i32, i32* %54
%82 = load i32, i32* %37
%83 = icmp slt i32 %81, %82
br i1 %83, label %84, label %176
84: ; preds = %80
%85 = load double, double* %48
%86 = load double*, double** %52
%87 = load i32, i32* %54
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %86, i64 %88
%90 = load double, double* %89
%91 = fadd double %85, %90
store double %91, double* %57
%92 = getelementptr inbounds [12 x double], [12 x double]* %55, i64 0, i64 0
%93 = load [12 x double]*, [12 x double]** %46
%94 = load i32, i32* %54
%95 = sub nsw i32 %94, 1
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [12 x double], [12 x double]* %93, i64 %96
%98 = getelementptr inbounds [12 x double], [12 x double]* %97, i64 0, i64 0
%99 = load double, double* %27
%100 = load double, double* %30
%101 = load double, double* %29
%102 = load double, double* %31
%103 = load [126 x double]*, [126 x double]** %38
%104 = bitcast [126 x double]* %103 to double**
%105 = load [126 x double]*, [126 x double]** %39
%106 = bitcast [126 x double]* %105 to double**
%107 = load [126 x double]*, [126 x double]** %40
%108 = bitcast [126 x double]* %107 to double**
%109 = load [126 x double]*, [126 x double]** %41
%110 = bitcast [126 x double]* %109 to double**
%111 = load [126 x double]*, [126 x double]** %42
%112 = bitcast [126 x double]* %111 to double**
%113 = load [126 x double]*, [126 x double]** %43
%114 = bitcast [126 x double]* %113 to double**
%115 = load [126 x double]*, [126 x double]** %44
%116 = bitcast [126 x double]* %115 to double**
%117 = load [126 x double]*, [126 x double]** %45
%118 = bitcast [126 x double]* %117 to double**
%119 = load double, double* %32
%120 = load double, double* %33
%121 = load double, double* %34
%122 = load double, double* %35
%123 = load double, double* %57
%124 = load double, double* %49
%125 = load double, double* %50
%126 = load double, double* %51
%127 = call i32 @mathModel(double* %92, double* %98, double %99, double %100, double %101, double %102, double** %104, double** %106, double** %108, double** %110, double** %112, double** %114, double** %116, double** %118, double %119, double %120, double %121, double %122, double %123, double %124, double %125, double %126)
store i32 0, i32* %53
br label %128
128: ; preds = %154, %84
%129 = load i32, i32* %53
%130 = icmp slt i32 %129, 12
br i1 %130, label %131, label %157
131: ; preds = %128
%132 = load [12 x double]*, [12 x double]** %46
%133 = load i32, i32* %54
%134 = sub nsw i32 %133, 1
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [12 x double], [12 x double]* %132, i64 %135
%137 = load i32, i32* %53
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [12 x double], [12 x double]* %136, i64 0, i64 %138
%140 = load double, double* %139
%141 = load double, double* %36
%142 = load i32, i32* %53
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [12 x double], [12 x double]* %55, i64 0, i64 %143
%145 = load double, double* %144
%146 = call double @llvm.fmuladd.f64(double %141, double %145, double %140)
%147 = load [12 x double]*, [12 x double]** %46
%148 = load i32, i32* %54
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [12 x double], [12 x double]* %147, i64 %149
%151 = load i32, i32* %53
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [12 x double], [12 x double]* %150, i64 0, i64 %152
store double %146, double* %153
br label %154
154: ; preds = %131
%155 = load i32, i32* %53
%156 = add nsw i32 %155, 1
store i32 %156, i32* %53
br label %128
157: ; preds = %128
%158 = load double, double* %56
%159 = load double, double* %36
%160 = fadd double %158, %159
store double %160, double* %56
%161 = load i32, i32* %58
%162 = icmp eq i32 %161, 100
br i1 %162, label %163, label %165
163: ; preds = %157
%164 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %58
br label %165
165: ; preds = %163, %157
%166 = load i32, i32* %58
%167 = add nsw i32 %166, 1
store i32 %167, i32* %58
%168 = load double, double* %27
%169 = load double, double* %36
%170 = load double, double* %28
%171 = fneg double %169
%172 = call double @llvm.fmuladd.f64(double %171, double %170, double %168)
store double %172, double* %27
br label %173
173: ; preds = %165
%174 = load i32, i32* %54
%175 = add nsw i32 %174, 1
store i32 %175, i32* %54
br label %80
176: ; preds = %80
%177 = load double, double* %27
%178 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), double %177)
%179 = load double, double* %59
%180 = load double, double* %27
%181 = fsub double %179, %180
%182 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0), double %181)
ret void
}

LLVM IR (-O2):
@.str.1 = [21 x i8] c"\0AFinal mass is: %lg\0A\00"
@.str.2 = [24 x i8] c"Mass variation is: %lg\0A\00"
define void @ode1(double %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, double %8, double %9, i32 %10, [126 x double]* %11, [126 x double]* %12, [126 x double]* %13, [126 x double]* %14, [126 x double]* %15, [126 x double]* %16, [126 x double]* %17, [126 x double]* %18, [12 x double]* %19, double* nocapture %20, double %21, double %22, double %23, double %24, double* nocapture %25) {
%27 = alloca [12 x double]
%28 = bitcast [12 x double]* %27 to i8*
%29 = load double, double* %20
%30 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 0, i64 0
store double %29, double* %30
%31 = getelementptr inbounds double, double* %20, i64 1
%32 = load double, double* %31
%33 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 0, i64 1
store double %32, double* %33
%34 = getelementptr inbounds double, double* %20, i64 2
%35 = load double, double* %34
%36 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 0, i64 2
store double %35, double* %36
%37 = getelementptr inbounds double, double* %20, i64 3
%38 = load double, double* %37
%39 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 0, i64 3
store double %38, double* %39
%40 = getelementptr inbounds double, double* %20, i64 4
%41 = load double, double* %40
%42 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 0, i64 4
store double %41, double* %42
%43 = getelementptr inbounds double, double* %20, i64 5
%44 = load double, double* %43
%45 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 0, i64 5
store double %44, double* %45
%46 = getelementptr inbounds double, double* %20, i64 6
%47 = load double, double* %46
%48 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 0, i64 6
store double %47, double* %48
%49 = getelementptr inbounds double, double* %20, i64 7
%50 = load double, double* %49
%51 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 0, i64 7
store double %50, double* %51
%52 = getelementptr inbounds double, double* %20, i64 8
%53 = load double, double* %52
%54 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 0, i64 8
store double %53, double* %54
%55 = getelementptr inbounds double, double* %20, i64 9
%56 = load double, double* %55
%57 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 0, i64 9
store double %56, double* %57
%58 = getelementptr inbounds double, double* %20, i64 10
%59 = load double, double* %58
%60 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 0, i64 10
store double %59, double* %60
%61 = getelementptr inbounds double, double* %20, i64 11
%62 = load double, double* %61
%63 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 0, i64 11
store double %62, double* %63
%64 = icmp sgt i32 %10, 1
br i1 %64, label %65, label %160
65: ; preds = %26
%66 = getelementptr inbounds [12 x double], [12 x double]* %27, i64 0, i64 0
%67 = bitcast [126 x double]* %11 to double**
%68 = bitcast [126 x double]* %12 to double**
%69 = bitcast [126 x double]* %13 to double**
%70 = bitcast [126 x double]* %14 to double**
%71 = bitcast [126 x double]* %15 to double**
%72 = bitcast [126 x double]* %16 to double**
%73 = bitcast [126 x double]* %17 to double**
%74 = bitcast [126 x double]* %18 to double**
%75 = fneg double %9
%76 = zext i32 %10 to i64
%77 = getelementptr inbounds [12 x double], [12 x double]* %27, i64 0, i64 2
%78 = getelementptr inbounds [12 x double], [12 x double]* %27, i64 0, i64 4
%79 = getelementptr inbounds [12 x double], [12 x double]* %27, i64 0, i64 6
%80 = getelementptr inbounds [12 x double], [12 x double]* %27, i64 0, i64 8
%81 = getelementptr inbounds [12 x double], [12 x double]* %27, i64 0, i64 10
%82 = insertelement <2 x double> poison, double %9, i64 0
%83 = shufflevector <2 x double> %82, <2 x double> poison, <2 x i32> zeroinitializer
%84 = insertelement <2 x double> poison, double %9, i64 0
%85 = shufflevector <2 x double> %84, <2 x double> poison, <2 x i32> zeroinitializer
%86 = insertelement <2 x double> poison, double %9, i64 0
%87 = shufflevector <2 x double> %86, <2 x double> poison, <2 x i32> zeroinitializer
%88 = insertelement <2 x double> poison, double %9, i64 0
%89 = shufflevector <2 x double> %88, <2 x double> poison, <2 x i32> zeroinitializer
%90 = insertelement <2 x double> poison, double %9, i64 0
%91 = shufflevector <2 x double> %90, <2 x double> poison, <2 x i32> zeroinitializer
%92 = insertelement <2 x double> poison, double %9, i64 0
%93 = shufflevector <2 x double> %92, <2 x double> poison, <2 x i32> zeroinitializer
%94 = bitcast [12 x double]* %27 to <2 x double>*
%95 = bitcast double* %77 to <2 x double>*
%96 = bitcast double* %78 to <2 x double>*
%97 = bitcast double* %79 to <2 x double>*
%98 = bitcast double* %80 to <2 x double>*
%99 = bitcast double* %81 to <2 x double>*
br label %100
100: ; preds = %65, %154
%101 = phi i64 [ 1, %65 ], [ %158, %154 ]
%102 = phi double [ %0, %65 ], [ %157, %154 ]
%103 = phi i32 [ 0, %65 ], [ %156, %154 ]
%104 = getelementptr inbounds double, double* %25, i64 %101
%105 = load double, double* %104
%106 = fadd double %105, %21
%107 = add nsw i64 %101, -1
%108 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 %107, i64 0
%109 = call i32 @mathModel(double* %66, double* %108, double %102, double %3, double %2, double %4, double** %67, double** %68, double** %69, double** %70, double** %71, double** %72, double** %73, double** %74, double %5, double %6, double %7, double %8, double %106, double %22, double %23, double %24)
%110 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 %101, i64 0
%111 = bitcast double* %108 to <2 x double>*
%112 = load <2 x double>, <2 x double>* %111
%113 = load <2 x double>, <2 x double>* %94
%114 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %83, <2 x double> %113, <2 x double> %112)
%115 = bitcast double* %110 to <2 x double>*
store <2 x double> %114, <2 x double>* %115
%116 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 %107, i64 2
%117 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 %101, i64 2
%118 = bitcast double* %116 to <2 x double>*
%119 = load <2 x double>, <2 x double>* %118
%120 = load <2 x double>, <2 x double>* %95
%121 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %85, <2 x double> %120, <2 x double> %119)
%122 = bitcast double* %117 to <2 x double>*
store <2 x double> %121, <2 x double>* %122
%123 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 %107, i64 4
%124 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 %101, i64 4
%125 = bitcast double* %123 to <2 x double>*
%126 = load <2 x double>, <2 x double>* %125
%127 = load <2 x double>, <2 x double>* %96
%128 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %87, <2 x double> %127, <2 x double> %126)
%129 = bitcast double* %124 to <2 x double>*
store <2 x double> %128, <2 x double>* %129
%130 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 %107, i64 6
%131 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 %101, i64 6
%132 = bitcast double* %130 to <2 x double>*
%133 = load <2 x double>, <2 x double>* %132
%134 = load <2 x double>, <2 x double>* %97
%135 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %89, <2 x double> %134, <2 x double> %133)
%136 = bitcast double* %131 to <2 x double>*
store <2 x double> %135, <2 x double>* %136
%137 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 %107, i64 8
%138 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 %101, i64 8
%139 = bitcast double* %137 to <2 x double>*
%140 = load <2 x double>, <2 x double>* %139
%141 = load <2 x double>, <2 x double>* %98
%142 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %91, <2 x double> %141, <2 x double> %140)
%143 = bitcast double* %138 to <2 x double>*
store <2 x double> %142, <2 x double>* %143
%144 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 %107, i64 10
%145 = getelementptr inbounds [12 x double], [12 x double]* %19, i64 %101, i64 10
%146 = bitcast double* %144 to <2 x double>*
%147 = load <2 x double>, <2 x double>* %146
%148 = load <2 x double>, <2 x double>* %99
%149 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %93, <2 x double> %148, <2 x double> %147)
%150 = bitcast double* %145 to <2 x double>*
store <2 x double> %149, <2 x double>* %150
%151 = icmp eq i32 %103, 100
br i1 %151, label %152, label %154
152: ; preds = %100
%153 = call i32 @putchar(i32 46)
br label %154
154: ; preds = %152, %100
%155 = phi i32 [ 0, %152 ], [ %103, %100 ]
%156 = add nsw i32 %155, 1
%157 = call double @llvm.fmuladd.f64(double %75, double %1, double %102)
%158 = add nuw nsw i64 %101, 1
%159 = icmp eq i64 %158, %76
br i1 %159, label %160, label %100
160: ; preds = %154, %26
%161 = phi double [ %0, %26 ], [ %157, %154 ]
%162 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), double %161)
%163 = fsub double %0, %161
%164 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0), double %163)
ret void
}