#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 */
scalar_t__ fabs(float);
int /*<<< orphan*/ free_ivector(int *, int, int);
int /*<<< orphan*/ free_matrix(float **, int, int, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
int *ivector(int, int);
float **matrix(int, int, int, int);
int /*<<< orphan*/ usrfun(float *, int, float *, float **);
float *vector(int, int);
void mnewt(int ntrial, float x[], int n, float tolx, float tolf) {
  void lubksb(float **a, int n, int *indx, float b[]);
  void ludcmp(float **a, int n, int *indx, float *d);
  int k, i, *indx;
  float errx, errf, d, *fvec, **fjac, *p;
  indx = ivector(1, n);
  p = vector(1, n);
  fvec = vector(1, n);
  fjac = matrix(1, n, 1, n);
  for (k = 1; k <= ntrial; k++) {
    usrfun(x, n, fvec, fjac);
    errf = 0.0;
    for (i = 1; i <= n; i++)
      errf += fabs(fvec[i]);
    if (errf <= tolf) {
      free_matrix(fjac, 1, n, 1, n);
      free_vector(fvec, 1, n);
      free_vector(p, 1, n);
      free_ivector(indx, 1, n);
      return;
    }
    for (i = 1; i <= n; i++)
      p[i] = -fvec[i];
    ludcmp(fjac, n, indx, &d);
    lubksb(fjac, n, indx, p);
    errx = 0.0;
    for (i = 1; i <= n; i++) {
      errx += fabs(p[i]);
      x[i] += p[i];
    }
    if (errx <= tolx) {
      free_matrix(fjac, 1, n, 1, n);
      free_vector(fvec, 1, n);
      free_vector(p, 1, n);
      free_ivector(indx, 1, n);
      return;
    }
  }
  {
    free_matrix(fjac, 1, n, 1, n);
    free_vector(fvec, 1, n);
    free_vector(p, 1, n);
    free_ivector(indx, 1, n);
    return;
  }
}


x86 assembly (clang, -O0):
<mnewt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
movss  %xmm1,-0x1c(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   10c0 <ivector@plt>
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   10a0 <vector@plt>
mov    %rax,-0x58(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   10a0 <vector@plt>
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%esi
mov    -0x14(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1090 <matrix@plt>
mov    %rax,-0x50(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1426 <mnewt+0x286>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x48(%rbp),%rdx
mov    -0x50(%rbp),%rcx
call   1070 <usrfun@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1276 <mnewt+0xd6>
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1060 <fabs@plt>
cvtsi2ss %rax,%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    123b <mnewt+0x9b>
movss  -0x38(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     12d8 <mnewt+0x138>
mov    -0x50(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    -0x14(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0x48(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x58(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   10b0 <free_ivector@plt>
jmp    1470 <mnewt+0x2d0>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1320 <mnewt+0x180>
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12df <mnewt+0x13f>
mov    -0x50(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x30(%rbp),%rdx
lea    -0x3c(%rbp),%rcx
call   1030 <ludcmp@plt>
mov    -0x50(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x30(%rbp),%rdx
mov    -0x58(%rbp),%rcx
call   1080 <lubksb@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     13b1 <mnewt+0x211>
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1060 <fabs@plt>
cvtsi2ss %rax,%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1357 <mnewt+0x1b7>
movss  -0x34(%rbp),%xmm1
movss  -0x18(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     1413 <mnewt+0x273>
mov    -0x50(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    -0x14(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0x48(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x58(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   10b0 <free_ivector@plt>
jmp    1470 <mnewt+0x2d0>
jmp    1418 <mnewt+0x278>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    120c <mnewt+0x6c>
mov    -0x50(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    -0x14(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0x48(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x58(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   10b0 <free_ivector@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mnewt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
movss  %xmm1,0xc(%rsp)
movss  %xmm0,0x30(%rsp)
mov    %edx,%ebx
mov    %rsi,%r12
mov    %edi,%ebp
mov    $0x1,%eax
mov    %rax,0x40(%rsp)
mov    $0x1,%edi
mov    %edx,%esi
call   10c0 <ivector@plt>
mov    %rax,0x20(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
call   10a0 <vector@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    %ebx,%esi
call   10a0 <vector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    %ebx,%esi
mov    $0x1,%edx
mov    %ebx,%ecx
call   1090 <matrix@plt>
mov    %rax,0x10(%rsp)
mov    %ebp,0x2c(%rsp)
test   %ebp,%ebp
mov    %rbx,%rbp
jle    1726 <mnewt+0x586>
lea    0x1(%rbp),%edi
mov    %rdi,0x80(%rsp)
lea    0x0(,%rdi,4),%rax
add    %r13,%rax
mov    %r13,%rcx
add    $0x4,%rcx
lea    0x4(%r14),%rdx
lea    (%r14,%rdi,4),%rsi
mov    %rbp,%r8
lea    -0x1(%rdi),%rbp
lea    -0x2(%rdi),%rbx
mov    %rbx,0x38(%rsp)
add    $0xfffffffffffffff7,%rdi
mov    %rdi,0x68(%rsp)
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %ebp,%r15d
and    $0x3,%r15d
mov    %rbp,%rbx
and    $0xfffffffffffffffc,%rbx
mov    %rbx,0x78(%rsp)
cmp    %rsi,%rcx
setb   %cl
cmp    %rax,%rdx
setb   %al
and    %cl,%al
mov    %al,0xb(%rsp)
mov    %rbp,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x58(%rsp)
add    $0x1,%rax
mov    %rax,0x50(%rsp)
mov    %rdi,%rax
mov    %rdi,0x60(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x48(%rsp)
mov    %rbp,%rax
mov    %rbp,0x18(%rsp)
mov    %rbp,%rbx
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbx
neg    %rbx
mov    %r8,0x88(%rsp)
mov    %r15,0x90(%rsp)
mov    %rbx,0x70(%rsp)
nop
mov    %r12,%rdi
mov    %ebp,%esi
mov    %r14,%rdx
mov    0x10(%rsp),%rcx
call   1070 <usrfun@plt>
test   %ebp,%ebp
jle    1320 <mnewt+0x180>
cmpq   $0x3,0x38(%rsp)
jae    1340 <mnewt+0x1a0>
xorps  %xmm1,%xmm1
mov    $0x1,%ebx
test   %r15,%r15
jne    13e6 <mnewt+0x246>
jmp    141b <mnewt+0x27b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0xc(%rsp),%xmm0
ucomiss 0xce3(%rip),%xmm0
jb     15c0 <mnewt+0x420>
jmp    1726 <mnewt+0x586>
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
xor    %ebx,%ebx
mov    0x78(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movss  %xmm1,0x4(%rsp)
movss  0x4(%r14,%rbx,4),%xmm0
call   1060 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%rsp),%xmm0
movss  %xmm0,0x4(%rsp)
movss  0x8(%r14,%rbx,4),%xmm0
call   1060 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%rsp),%xmm0
movss  %xmm0,0x4(%rsp)
movss  0xc(%r14,%rbx,4),%xmm0
call   1060 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%rsp),%xmm0
movss  %xmm0,0x4(%rsp)
movss  0x10(%r14,%rbx,4),%xmm0
call   1060 <fabs@plt>
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
addss  0x4(%rsp),%xmm1
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    1350 <mnewt+0x1b0>
add    $0x1,%rbx
test   %r15,%r15
je     141b <mnewt+0x27b>
lea    (%r14,%rbx,4),%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movss  %xmm1,0x4(%rsp)
movss  (%rbx,%rbp,4),%xmm0
call   1060 <fabs@plt>
movss  0x4(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  %xmm0,%xmm1
add    $0x1,%rbp
cmp    %rbp,%r15
jne    13f0 <mnewt+0x250>
movss  0xc(%rsp),%xmm0
ucomiss %xmm1,%xmm0
mov    0x88(%rsp),%rbp
mov    0x80(%rsp),%rsi
movaps 0xbc5(%rip),%xmm2
jae    1726 <mnewt+0x586>
test   %ebp,%ebp
jle    1470 <mnewt+0x2d0>
cmpq   $0x8,0x18(%rsp)
setb   %al
or     0xb(%rsp),%al
mov    $0x1,%eax
jne    1537 <mnewt+0x397>
cmpq   $0x8,0x68(%rsp)
jae    14a4 <mnewt+0x304>
xor    %eax,%eax
jmp    14f6 <mnewt+0x356>
nopl   0x0(%rax)
mov    0x10(%rsp),%rbx
mov    %rbx,%rdi
mov    %ebp,%esi
mov    0x20(%rsp),%r15
mov    %r15,%rdx
lea    0x34(%rsp),%rcx
call   1030 <ludcmp@plt>
mov    %rbx,%rdi
mov    %ebp,%esi
mov    %r15,%rdx
mov    %r13,%rcx
call   1080 <lubksb@plt>
xorps  %xmm1,%xmm1
jmp    16fc <mnewt+0x55c>
mov    0x48(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups 0x4(%r14,%rax,4),%xmm0
movups 0x14(%r14,%rax,4),%xmm1
xorps  %xmm2,%xmm0
xorps  %xmm2,%xmm1
movups %xmm0,0x4(%r13,%rax,4)
movups %xmm1,0x14(%r13,%rax,4)
movups 0x24(%r14,%rax,4),%xmm0
movups 0x34(%r14,%rax,4),%xmm1
xorps  %xmm2,%xmm0
xorps  %xmm2,%xmm1
movups %xmm0,0x24(%r13,%rax,4)
movups %xmm1,0x34(%r13,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    14b0 <mnewt+0x310>
testb  $0x1,0x60(%rsp)
je     1522 <mnewt+0x382>
shl    $0x2,%rax
or     $0x4,%rax
movups (%r14,%rax,1),%xmm0
movups 0x10(%r14,%rax,1),%xmm1
xorps  %xmm2,%xmm0
xorps  %xmm2,%xmm1
movups %xmm0,0x0(%r13,%rax,1)
movups %xmm1,0x10(%r13,%rax,1)
mov    0x50(%rsp),%rax
mov    0x58(%rsp),%rcx
cmp    %rcx,0x18(%rsp)
je     15c0 <mnewt+0x420>
mov    %esi,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %rsi,%rcx
and    $0x3,%rdx
je     156a <mnewt+0x3ca>
nopw   0x0(%rax,%rax,1)
movss  (%r14,%rax,4),%xmm0
xorps  %xmm2,%xmm0
movss  %xmm0,0x0(%r13,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1550 <mnewt+0x3b0>
cmp    $0x3,%rcx
jb     15c0 <mnewt+0x420>
movss  (%r14,%rax,4),%xmm0
xorps  %xmm2,%xmm0
movss  %xmm0,0x0(%r13,%rax,4)
movss  0x4(%r14,%rax,4),%xmm0
xorps  %xmm2,%xmm0
movss  %xmm0,0x4(%r13,%rax,4)
movss  0x8(%r14,%rax,4),%xmm0
xorps  %xmm2,%xmm0
movss  %xmm0,0x8(%r13,%rax,4)
movss  0xc(%r14,%rax,4),%xmm0
xorps  %xmm2,%xmm0
movss  %xmm0,0xc(%r13,%rax,4)
add    $0x4,%rax
cmp    %rax,%rsi
jne    1570 <mnewt+0x3d0>
nopl   0x0(%rax)
mov    0x10(%rsp),%r15
mov    %r15,%rdi
mov    %ebp,%esi
mov    %rbp,%rbx
mov    0x20(%rsp),%rbp
mov    %rbp,%rdx
lea    0x34(%rsp),%rcx
call   1030 <ludcmp@plt>
mov    %r15,%rdi
mov    %ebx,%esi
mov    %rbp,%rdx
mov    %rbx,%rbp
mov    %r13,%rcx
call   1080 <lubksb@plt>
test   %ebp,%ebp
jle    16b0 <mnewt+0x510>
cmpq   $0x0,0x38(%rsp)
je     16b5 <mnewt+0x515>
xorps  %xmm1,%xmm1
mov    $0x1,%r15d
mov    0x70(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  %xmm1,0x4(%rsp)
movss  0x0(%r13,%r15,4),%xmm0
call   1060 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%rsp),%xmm0
movss  %xmm0,0x4(%rsp)
movss  0x0(%r13,%r15,4),%xmm0
addss  (%r12,%r15,4),%xmm0
movss  %xmm0,(%r12,%r15,4)
movss  0x4(%r13,%r15,4),%xmm0
call   1060 <fabs@plt>
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
addss  0x4(%rsp),%xmm1
movss  0x4(%r13,%r15,4),%xmm0
addss  0x4(%r12,%r15,4),%xmm0
movss  %xmm0,0x4(%r12,%r15,4)
lea    (%rbx,%r15,1),%rax
add    $0x2,%rax
add    $0x2,%r15
cmp    $0x1,%rax
jne    1620 <mnewt+0x480>
testb  $0x1,0x18(%rsp)
jne    16c5 <mnewt+0x525>
jmp    16fc <mnewt+0x55c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm1,%xmm1
jmp    16fc <mnewt+0x55c>
xorps  %xmm1,%xmm1
mov    $0x1,%r15d
testb  $0x1,0x18(%rsp)
je     16fc <mnewt+0x55c>
movss  0x0(%r13,%r15,4),%xmm0
movss  %xmm1,0x4(%rsp)
call   1060 <fabs@plt>
movss  0x4(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  %xmm0,%xmm1
movss  0x0(%r13,%r15,4),%xmm0
addss  (%r12,%r15,4),%xmm0
movss  %xmm0,(%r12,%r15,4)
movss  0x30(%rsp),%xmm0
ucomiss %xmm1,%xmm0
mov    0x40(%rsp),%rcx
mov    0x90(%rsp),%r15
jae    1726 <mnewt+0x586>
lea    0x1(%rcx),%eax
cmp    0x2c(%rsp),%ecx
mov    %rax,0x40(%rsp)
jne    12e0 <mnewt+0x140>
mov    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    %ebp,%edx
mov    $0x1,%ecx
mov    %ebp,%r8d
call   1040 <free_matrix@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %ebp,%edx
call   1050 <free_vector@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    %ebp,%edx
call   1050 <free_vector@plt>
mov    0x20(%rsp),%rdi
mov    $0x1,%esi
mov    %ebp,%edx
call   10b0 <free_ivector@plt>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @mnewt(i32 %0, float* %1, i32 %2, float %3, float %4) {
%6 = alloca i32
%7 = alloca float*
%8 = alloca i32
%9 = alloca float
%10 = alloca float
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32*
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float*
%18 = alloca float**
%19 = alloca float*
store i32 %0, i32* %6
store float* %1, float** %7
store i32 %2, i32* %8
store float %3, float* %9
store float %4, float* %10
%20 = load i32, i32* %8
%21 = call i32* @ivector(i32 1, i32 %20)
store i32* %21, i32** %13
%22 = load i32, i32* %8
%23 = call float* @vector(i32 1, i32 %22)
store float* %23, float** %19
%24 = load i32, i32* %8
%25 = call float* @vector(i32 1, i32 %24)
store float* %25, float** %17
%26 = load i32, i32* %8
%27 = load i32, i32* %8
%28 = call float** @matrix(i32 1, i32 %26, i32 1, i32 %27)
store float** %28, float*** %18
store i32 1, i32* %11
br label %29
29: ; preds = %148, %5
%30 = load i32, i32* %11
%31 = load i32, i32* %6
%32 = icmp sle i32 %30, %31
br i1 %32, label %33, label %151
33: ; preds = %29
%34 = load float*, float** %7
%35 = load i32, i32* %8
%36 = load float*, float** %17
%37 = load float**, float*** %18
%38 = call i32 @usrfun(float* %34, i32 %35, float* %36, float** %37)
store float 0.000000e+00, float* %15
store i32 1, i32* %12
br label %39
39: ; preds = %53, %33
%40 = load i32, i32* %12
%41 = load i32, i32* %8
%42 = icmp sle i32 %40, %41
br i1 %42, label %43, label %56
43: ; preds = %39
%44 = load float*, float** %17
%45 = load i32, i32* %12
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float, float* %44, i64 %46
%48 = load float, float* %47
%49 = call i64 @fabs(float %48)
%50 = sitofp i64 %49 to float
%51 = load float, float* %15
%52 = fadd float %51, %50
store float %52, float* %15
br label %53
53: ; preds = %43
%54 = load i32, i32* %12
%55 = add nsw i32 %54, 1
store i32 %55, i32* %12
br label %39
56: ; preds = %39
%57 = load float, float* %15
%58 = load float, float* %10
%59 = fcmp ole float %57, %58
br i1 %59, label %60, label %74
60: ; preds = %56
%61 = load float**, float*** %18
%62 = load i32, i32* %8
%63 = load i32, i32* %8
%64 = call i32 @free_matrix(float** %61, i32 1, i32 %62, i32 1, i32 %63)
%65 = load float*, float** %17
%66 = load i32, i32* %8
%67 = call i32 @free_vector(float* %65, i32 1, i32 %66)
%68 = load float*, float** %19
%69 = load i32, i32* %8
%70 = call i32 @free_vector(float* %68, i32 1, i32 %69)
%71 = load i32*, i32** %13
%72 = load i32, i32* %8
%73 = call i32 @free_ivector(i32* %71, i32 1, i32 %72)
br label %165
74: ; preds = %56
store i32 1, i32* %12
br label %75
75: ; preds = %90, %74
%76 = load i32, i32* %12
%77 = load i32, i32* %8
%78 = icmp sle i32 %76, %77
br i1 %78, label %79, label %93
79: ; preds = %75
%80 = load float*, float** %17
%81 = load i32, i32* %12
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds float, float* %80, i64 %82
%84 = load float, float* %83
%85 = fneg float %84
%86 = load float*, float** %19
%87 = load i32, i32* %12
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %86, i64 %88
store float %85, float* %89
br label %90
90: ; preds = %79
%91 = load i32, i32* %12
%92 = add nsw i32 %91, 1
store i32 %92, i32* %12
br label %75
93: ; preds = %75
%94 = load float**, float*** %18
%95 = load i32, i32* %8
%96 = load i32*, i32** %13
%97 = load float**, float*** %18
%98 = load i32, i32* %8
%99 = load i32*, i32** %13
%100 = load float*, float** %19
store float 0.000000e+00, float* %14
store i32 1, i32* %12
br label %101
101: ; preds = %126, %93
%102 = load i32, i32* %12
%103 = load i32, i32* %8
%104 = icmp sle i32 %102, %103
br i1 %104, label %105, label %129
105: ; preds = %101
%106 = load float*, float** %19
%107 = load i32, i32* %12
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds float, float* %106, i64 %108
%110 = load float, float* %109
%111 = call i64 @fabs(float %110)
%112 = sitofp i64 %111 to float
%113 = load float, float* %14
%114 = fadd float %113, %112
store float %114, float* %14
%115 = load float*, float** %19
%116 = load i32, i32* %12
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %115, i64 %117
%119 = load float, float* %118
%120 = load float*, float** %7
%121 = load i32, i32* %12
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds float, float* %120, i64 %122
%124 = load float, float* %123
%125 = fadd float %124, %119
store float %125, float* %123
br label %126
126: ; preds = %105
%127 = load i32, i32* %12
%128 = add nsw i32 %127, 1
store i32 %128, i32* %12
br label %101
129: ; preds = %101
%130 = load float, float* %14
%131 = load float, float* %9
%132 = fcmp ole float %130, %131
br i1 %132, label %133, label %147
133: ; preds = %129
%134 = load float**, float*** %18
%135 = load i32, i32* %8
%136 = load i32, i32* %8
%137 = call i32 @free_matrix(float** %134, i32 1, i32 %135, i32 1, i32 %136)
%138 = load float*, float** %17
%139 = load i32, i32* %8
%140 = call i32 @free_vector(float* %138, i32 1, i32 %139)
%141 = load float*, float** %19
%142 = load i32, i32* %8
%143 = call i32 @free_vector(float* %141, i32 1, i32 %142)
%144 = load i32*, i32** %13
%145 = load i32, i32* %8
%146 = call i32 @free_ivector(i32* %144, i32 1, i32 %145)
br label %165
147: ; preds = %129
br label %148
148: ; preds = %147
%149 = load i32, i32* %11
%150 = add nsw i32 %149, 1
store i32 %150, i32* %11
br label %29
151: ; preds = %29
%152 = load float**, float*** %18
%153 = load i32, i32* %8
%154 = load i32, i32* %8
%155 = call i32 @free_matrix(float** %152, i32 1, i32 %153, i32 1, i32 %154)
%156 = load float*, float** %17
%157 = load i32, i32* %8
%158 = call i32 @free_vector(float* %156, i32 1, i32 %157)
%159 = load float*, float** %19
%160 = load i32, i32* %8
%161 = call i32 @free_vector(float* %159, i32 1, i32 %160)
%162 = load i32*, i32** %13
%163 = load i32, i32* %8
%164 = call i32 @free_ivector(i32* %162, i32 1, i32 %163)
br label %165
165: ; preds = %151, %133, %60
ret void
}

LLVM IR (-O2):
define void @mnewt(i32 %0, float* %1, i32 %2, float %3, float %4) {
%6 = alloca float
%7 = bitcast float* %6 to i8*
%8 = tail call i32* @ivector(i32 1, i32 %2)
%9 = tail call float* @vector(i32 1, i32 %2)
%10 = tail call float* @vector(i32 1, i32 %2)
%11 = tail call float** @matrix(i32 1, i32 %2, i32 1, i32 %2)
%12 = icmp slt i32 %0, 1
br i1 %12, label %247, label %13
13: ; preds = %5
%14 = icmp slt i32 %2, 1
%15 = add i32 %2, 1
%16 = zext i32 %15 to i64
%17 = zext i32 %15 to i64
%18 = fcmp ult float %4, 0.000000e+00
%19 = getelementptr float, float* %9, i64 1
%20 = getelementptr float, float* %9, i64 %16
%21 = getelementptr float, float* %10, i64 1
%22 = getelementptr float, float* %10, i64 %16
%23 = add nsw i64 %16, -1
%24 = add nsw i64 %16, -1
%25 = add nsw i64 %16, -2
%26 = add nsw i64 %16, -9
%27 = lshr i64 %26, 3
%28 = add nuw nsw i64 %27, 1
%29 = and i64 %24, 3
%30 = icmp ult i64 %25, 3
%31 = and i64 %24, -4
%32 = icmp eq i64 %29, 0
%33 = icmp ult i64 %23, 8
%34 = icmp ult float* %19, %22
%35 = icmp ult float* %21, %20
%36 = and i1 %34, %35
%37 = and i64 %23, -8
%38 = or i64 %37, 1
%39 = and i64 %28, 1
%40 = icmp ult i64 %26, 8
%41 = and i64 %28, 4611686018427387902
%42 = icmp eq i64 %39, 0
%43 = icmp eq i64 %23, %37
%44 = and i64 %24, 1
%45 = icmp eq i64 %25, 0
%46 = and i64 %24, -2
%47 = icmp eq i64 %44, 0
br label %48
48: ; preds = %241, %13
%49 = phi i32 [ 1, %13 ], [ %244, %241 ]
%50 = call i32 @usrfun(float* %1, i32 %2, float* %10, float** %11)
br i1 %14, label %101, label %51
51: ; preds = %48
br i1 %30, label %82, label %52
52: ; preds = %51, %52
%53 = phi i64 [ %79, %52 ], [ 1, %51 ]
%54 = phi float [ %78, %52 ], [ 0.000000e+00, %51 ]
%55 = phi i64 [ %80, %52 ], [ 0, %51 ]
%56 = getelementptr inbounds float, float* %10, i64 %53
%57 = load float, float* %56
%58 = call i64 @fabs(float %57)
%59 = sitofp i64 %58 to float
%60 = fadd float %54, %59
%61 = add nuw nsw i64 %53, 1
%62 = getelementptr inbounds float, float* %10, i64 %61
%63 = load float, float* %62
%64 = call i64 @fabs(float %63)
%65 = sitofp i64 %64 to float
%66 = fadd float %60, %65
%67 = add nuw nsw i64 %53, 2
%68 = getelementptr inbounds float, float* %10, i64 %67
%69 = load float, float* %68
%70 = call i64 @fabs(float %69)
%71 = sitofp i64 %70 to float
%72 = fadd float %66, %71
%73 = add nuw nsw i64 %53, 3
%74 = getelementptr inbounds float, float* %10, i64 %73
%75 = load float, float* %74
%76 = call i64 @fabs(float %75)
%77 = sitofp i64 %76 to float
%78 = fadd float %72, %77
%79 = add nuw nsw i64 %53, 4
%80 = add i64 %55, 4
%81 = icmp eq i64 %80, %31
br i1 %81, label %82, label %52
82: ; preds = %52, %51
%83 = phi float [ undef, %51 ], [ %78, %52 ]
%84 = phi i64 [ 1, %51 ], [ %79, %52 ]
%85 = phi float [ 0.000000e+00, %51 ], [ %78, %52 ]
br i1 %32, label %98, label %86
86: ; preds = %82, %86
%87 = phi i64 [ %95, %86 ], [ %84, %82 ]
%88 = phi float [ %94, %86 ], [ %85, %82 ]
%89 = phi i64 [ %96, %86 ], [ 0, %82 ]
%90 = getelementptr inbounds float, float* %10, i64 %87
%91 = load float, float* %90
%92 = call i64 @fabs(float %91)
%93 = sitofp i64 %92 to float
%94 = fadd float %88, %93
%95 = add nuw nsw i64 %87, 1
%96 = add i64 %89, 1
%97 = icmp eq i64 %96, %29
br i1 %97, label %98, label %86
98: ; preds = %86, %82
%99 = phi float [ %83, %82 ], [ %94, %86 ]
%100 = fcmp ugt float %99, %4
br i1 %100, label %102, label %247
101: ; preds = %48
br i1 %18, label %198, label %247
102: ; preds = %98
br i1 %14, label %226, label %103
103: ; preds = %102
%104 = select i1 %33, i1 true, i1 %36
br i1 %104, label %155, label %105
105: ; preds = %103
br i1 %40, label %138, label %106
106: ; preds = %105, %106
%107 = phi i64 [ %135, %106 ], [ 0, %105 ]
%108 = phi i64 [ %136, %106 ], [ 0, %105 ]
%109 = or i64 %107, 1
%110 = getelementptr inbounds float, float* %10, i64 %109
%111 = bitcast float* %110 to <4 x float>*
%112 = load <4 x float>, <4 x float>* %111
%113 = getelementptr inbounds float, float* %110, i64 4
%114 = bitcast float* %113 to <4 x float>*
%115 = load <4 x float>, <4 x float>* %114
%116 = fneg <4 x float> %112
%117 = fneg <4 x float> %115
%118 = getelementptr inbounds float, float* %9, i64 %109
%119 = bitcast float* %118 to <4 x float>*
store <4 x float> %116, <4 x float>* %119
%120 = getelementptr inbounds float, float* %118, i64 4
%121 = bitcast float* %120 to <4 x float>*
store <4 x float> %117, <4 x float>* %121
%122 = or i64 %107, 9
%123 = getelementptr inbounds float, float* %10, i64 %122
%124 = bitcast float* %123 to <4 x float>*
%125 = load <4 x float>, <4 x float>* %124
%126 = getelementptr inbounds float, float* %123, i64 4
%127 = bitcast float* %126 to <4 x float>*
%128 = load <4 x float>, <4 x float>* %127
%129 = fneg <4 x float> %125
%130 = fneg <4 x float> %128
%131 = getelementptr inbounds float, float* %9, i64 %122
%132 = bitcast float* %131 to <4 x float>*
store <4 x float> %129, <4 x float>* %132
%133 = getelementptr inbounds float, float* %131, i64 4
%134 = bitcast float* %133 to <4 x float>*
store <4 x float> %130, <4 x float>* %134
%135 = add nuw i64 %107, 16
%136 = add i64 %108, 2
%137 = icmp eq i64 %136, %41
br i1 %137, label %138, label %106
138: ; preds = %106, %105
%139 = phi i64 [ 0, %105 ], [ %135, %106 ]
br i1 %42, label %154, label %140
140: ; preds = %138
%141 = or i64 %139, 1
%142 = getelementptr inbounds float, float* %10, i64 %141
%143 = bitcast float* %142 to <4 x float>*
%144 = load <4 x float>, <4 x float>* %143
%145 = getelementptr inbounds float, float* %142, i64 4
%146 = bitcast float* %145 to <4 x float>*
%147 = load <4 x float>, <4 x float>* %146
%148 = fneg <4 x float> %144
%149 = fneg <4 x float> %147
%150 = getelementptr inbounds float, float* %9, i64 %141
%151 = bitcast float* %150 to <4 x float>*
store <4 x float> %148, <4 x float>* %151
%152 = getelementptr inbounds float, float* %150, i64 4
%153 = bitcast float* %152 to <4 x float>*
store <4 x float> %149, <4 x float>* %153
br label %154
154: ; preds = %138, %140
br i1 %43, label %198, label %155
155: ; preds = %103, %154
%156 = phi i64 [ 1, %103 ], [ %38, %154 ]
%157 = sub nsw i64 %16, %156
%158 = xor i64 %156, -1
%159 = add nsw i64 %158, %16
%160 = and i64 %157, 3
%161 = icmp eq i64 %160, 0
br i1 %161, label %172, label %162
162: ; preds = %155, %162
%163 = phi i64 [ %169, %162 ], [ %156, %155 ]
%164 = phi i64 [ %170, %162 ], [ 0, %155 ]
%165 = getelementptr inbounds float, float* %10, i64 %163
%166 = load float, float* %165
%167 = fneg float %166
%168 = getelementptr inbounds float, float* %9, i64 %163
store float %167, float* %168
%169 = add nuw nsw i64 %163, 1
%170 = add i64 %164, 1
%171 = icmp eq i64 %170, %160
br i1 %171, label %172, label %162
172: ; preds = %162, %155
%173 = phi i64 [ %156, %155 ], [ %169, %162 ]
%174 = icmp ult i64 %159, 3
br i1 %174, label %198, label %175
175: ; preds = %172, %175
%176 = phi i64 [ %196, %175 ], [ %173, %172 ]
%177 = getelementptr inbounds float, float* %10, i64 %176
%178 = load float, float* %177
%179 = fneg float %178
%180 = getelementptr inbounds float, float* %9, i64 %176
store float %179, float* %180
%181 = add nuw nsw i64 %176, 1
%182 = getelementptr inbounds float, float* %10, i64 %181
%183 = load float, float* %182
%184 = fneg float %183
%185 = getelementptr inbounds float, float* %9, i64 %181
store float %184, float* %185
%186 = add nuw nsw i64 %176, 2
%187 = getelementptr inbounds float, float* %10, i64 %186
%188 = load float, float* %187
%189 = fneg float %188
%190 = getelementptr inbounds float, float* %9, i64 %186
store float %189, float* %190
%191 = add nuw nsw i64 %176, 3
%192 = getelementptr inbounds float, float* %10, i64 %191
%193 = load float, float* %192
%194 = fneg float %193
%195 = getelementptr inbounds float, float* %9, i64 %191
store float %194, float* %195
%196 = add nuw nsw i64 %176, 4
%197 = icmp eq i64 %196, %17
br i1 %197, label %198, label %175
198: ; preds = %172, %175, %154, %101
br i1 %14, label %241, label %199
199: ; preds = %198
br i1 %45, label %227, label %200
200: ; preds = %199, %200
%201 = phi i64 [ %223, %200 ], [ 1, %199 ]
%202 = phi float [ %218, %200 ], [ 0.000000e+00, %199 ]
%203 = phi i64 [ %224, %200 ], [ 0, %199 ]
%204 = getelementptr inbounds float, float* %9, i64 %201
%205 = load float, float* %204
%206 = call i64 @fabs(float %205)
%207 = sitofp i64 %206 to float
%208 = fadd float %202, %207
%209 = load float, float* %204
%210 = getelementptr inbounds float, float* %1, i64 %201
%211 = load float, float* %210
%212 = fadd float %209, %211
store float %212, float* %210
%213 = add nuw nsw i64 %201, 1
%214 = getelementptr inbounds float, float* %9, i64 %213
%215 = load float, float* %214
%216 = call i64 @fabs(float %215)
%217 = sitofp i64 %216 to float
%218 = fadd float %208, %217
%219 = load float, float* %214
%220 = getelementptr inbounds float, float* %1, i64 %213
%221 = load float, float* %220
%222 = fadd float %219, %221
store float %222, float* %220
%223 = add nuw nsw i64 %201, 2
%224 = add i64 %203, 2
%225 = icmp eq i64 %224, %46
br i1 %225, label %227, label %200
226: ; preds = %102
br label %241
227: ; preds = %200, %199
%228 = phi float [ undef, %199 ], [ %218, %200 ]
%229 = phi i64 [ 1, %199 ], [ %223, %200 ]
%230 = phi float [ 0.000000e+00, %199 ], [ %218, %200 ]
br i1 %47, label %241, label %231
231: ; preds = %227
%232 = getelementptr inbounds float, float* %9, i64 %229
%233 = load float, float* %232
%234 = call i64 @fabs(float %233)
%235 = sitofp i64 %234 to float
%236 = fadd float %230, %235
%237 = load float, float* %232
%238 = getelementptr inbounds float, float* %1, i64 %229
%239 = load float, float* %238
%240 = fadd float %237, %239
store float %240, float* %238
br label %241
241: ; preds = %231, %227, %226, %198
%242 = phi float [ 0.000000e+00, %198 ], [ 0.000000e+00, %226 ], [ %228, %227 ], [ %236, %231 ]
%243 = fcmp ole float %242, %3
%244 = add nuw i32 %49, 1
%245 = icmp eq i32 %49, %0
%246 = select i1 %243, i1 true, i1 %245
br i1 %246, label %247, label %48
247: ; preds = %241, %98, %101, %5
%248 = call i32 @free_matrix(float** %11, i32 1, i32 %2, i32 1, i32 %2)
%249 = call i32 @free_vector(float* %10, i32 1, i32 %2)
%250 = call i32 @free_vector(float* %9, i32 1, i32 %2)
%251 = call i32 @free_ivector(i32* %8, i32 1, i32 %2)
ret void
}