#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 */
float fabs(float);
void simp1(float **a, int mm, int ll[], int nll, int iabf, int *kp,
           float *bmax) {
  int k;
  float test;
  if (nll <= 0)
    *bmax = 0.0;
  else {
    *kp = ll[1];
    *bmax = a[mm + 1][*kp + 1];
    for (k = 2; k <= nll; k++) {
      if (iabf == 0)
        test = a[mm + 1][ll[k] + 1] - (*bmax);
      else
        test = fabs(a[mm + 1][ll[k] + 1]) - fabs(*bmax);
      if (test > 0.0) {
        *bmax = a[mm + 1][ll[k] + 1];
        *kp = ll[k];
      }
    }
  }
}


x86 assembly (clang, -O0):
<simp1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jg     114c <simp1+0x3c>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
jmp    1296 <simp1+0x186>
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1291 <simp1+0x181>
cmpl   $0x0,-0x20(%rbp)
jne    11d9 <simp1+0xc9>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
jmp    1228 <simp1+0x118>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x34(%rbp)
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
call   1030 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    127e <simp1+0x16e>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
jmp    1283 <simp1+0x173>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    118a <simp1+0x7a>
jmp    1296 <simp1+0x186>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<simp1>:
mov    0x8(%rsp),%r10
test   %ecx,%ecx
jle    1129 <simp1+0x29>
movslq 0x4(%rdx),%rax
mov    %eax,(%r9)
movslq %esi,%rsi
mov    0x8(%rdi,%rsi,8),%rsi
movss  0x4(%rsi,%rax,4),%xmm0
movss  %xmm0,(%r10)
cmp    $0x1,%ecx
jne    1131 <simp1+0x31>
ret
movl   $0x0,(%r10)
ret
add    $0x1,%ecx
mov    $0x2,%edi
xorps  %xmm1,%xmm1
movaps 0xebd(%rip),%xmm2
jmp    1159 <simp1+0x59>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdi
cmp    %rdi,%rcx
je     1128 <simp1+0x28>
movslq (%rdx,%rdi,4),%rax
movss  0x4(%rsi,%rax,4),%xmm3
movaps %xmm3,%xmm4
test   %r8d,%r8d
je     1180 <simp1+0x80>
andps  %xmm2,%xmm4
movaps %xmm0,%xmm5
andps  %xmm2,%xmm5
subss  %xmm5,%xmm4
ucomiss %xmm1,%xmm4
jbe    1150 <simp1+0x50>
jmp    1189 <simp1+0x89>
nop
subss  %xmm0,%xmm4
ucomiss %xmm1,%xmm4
jbe    1150 <simp1+0x50>
movss  %xmm3,(%r10)
mov    %eax,(%r9)
movaps %xmm3,%xmm0
jmp    1150 <simp1+0x50>

LLVM IR (-O0):
define void @simp1(float** %0, i32 %1, i32* %2, i32 %3, i32 %4, i32* %5, float* %6) {
%8 = alloca float**
%9 = alloca i32
%10 = alloca i32*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32*
%14 = alloca float*
%15 = alloca i32
%16 = alloca float
store float** %0, float*** %8
store i32 %1, i32* %9
store i32* %2, i32** %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32* %5, i32** %13
store float* %6, float** %14
%17 = load i32, i32* %11
%18 = icmp sle i32 %17, 0
br i1 %18, label %19, label %21
19: ; preds = %7
%20 = load float*, float** %14
store float 0.000000e+00, float* %20
br label %118
21: ; preds = %7
%22 = load i32*, i32** %10
%23 = getelementptr inbounds i32, i32* %22, i64 1
%24 = load i32, i32* %23
%25 = load i32*, i32** %13
store i32 %24, i32* %25
%26 = load float**, float*** %8
%27 = load i32, i32* %9
%28 = add nsw i32 %27, 1
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds float*, float** %26, i64 %29
%31 = load float*, float** %30
%32 = load i32*, i32** %13
%33 = load i32, i32* %32
%34 = add nsw i32 %33, 1
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds float, float* %31, i64 %35
%37 = load float, float* %36
%38 = load float*, float** %14
store float %37, float* %38
store i32 2, i32* %15
br label %39
39: ; preds = %114, %21
%40 = load i32, i32* %15
%41 = load i32, i32* %11
%42 = icmp sle i32 %40, %41
br i1 %42, label %43, label %117
43: ; preds = %39
%44 = load i32, i32* %12
%45 = icmp eq i32 %44, 0
br i1 %45, label %46, label %65
46: ; preds = %43
%47 = load float**, float*** %8
%48 = load i32, i32* %9
%49 = add nsw i32 %48, 1
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds float*, float** %47, i64 %50
%52 = load float*, float** %51
%53 = load i32*, i32** %10
%54 = load i32, i32* %15
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i32, i32* %53, i64 %55
%57 = load i32, i32* %56
%58 = add nsw i32 %57, 1
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds float, float* %52, i64 %59
%61 = load float, float* %60
%62 = load float*, float** %14
%63 = load float, float* %62
%64 = fsub float %61, %63
store float %64, float* %16
br label %86
65: ; preds = %43
%66 = load float**, float*** %8
%67 = load i32, i32* %9
%68 = add nsw i32 %67, 1
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float*, float** %66, i64 %69
%71 = load float*, float** %70
%72 = load i32*, i32** %10
%73 = load i32, i32* %15
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i32, i32* %72, i64 %74
%76 = load i32, i32* %75
%77 = add nsw i32 %76, 1
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float, float* %71, i64 %78
%80 = load float, float* %79
%81 = call float @fabs(float %80)
%82 = load float*, float** %14
%83 = load float, float* %82
%84 = call float @fabs(float %83)
%85 = fsub float %81, %84
store float %85, float* %16
br label %86
86: ; preds = %65, %46
%87 = load float, float* %16
%88 = fpext float %87 to double
%89 = fcmp ogt double %88, 0.000000e+00
br i1 %89, label %90, label %113
90: ; preds = %86
%91 = load float**, float*** %8
%92 = load i32, i32* %9
%93 = add nsw i32 %92, 1
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float*, float** %91, i64 %94
%96 = load float*, float** %95
%97 = load i32*, i32** %10
%98 = load i32, i32* %15
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %97, i64 %99
%101 = load i32, i32* %100
%102 = add nsw i32 %101, 1
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds float, float* %96, i64 %103
%105 = load float, float* %104
%106 = load float*, float** %14
store float %105, float* %106
%107 = load i32*, i32** %10
%108 = load i32, i32* %15
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i32, i32* %107, i64 %109
%111 = load i32, i32* %110
%112 = load i32*, i32** %13
store i32 %111, i32* %112
br label %113
113: ; preds = %90, %86
br label %114
114: ; preds = %113
%115 = load i32, i32* %15
%116 = add nsw i32 %115, 1
store i32 %116, i32* %15
br label %39
117: ; preds = %39
br label %118
118: ; preds = %117, %19
ret void
}

LLVM IR (-O2):
define void @simp1(float** nocapture %0, i32 %1, i32* nocapture %2, i32 %3, i32 %4, i32* nocapture writeonly %5, float* nocapture %6) {
%8 = icmp slt i32 %3, 1
br i1 %8, label %9, label %10
9: ; preds = %7
store float 0.000000e+00, float* %6
br label %52
10: ; preds = %7
%11 = getelementptr inbounds i32, i32* %2, i64 1
%12 = load i32, i32* %11
store i32 %12, i32* %5
%13 = add nsw i32 %1, 1
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds float*, float** %0, i64 %14
%16 = load float*, float** %15
%17 = add nsw i32 %12, 1
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds float, float* %16, i64 %18
%20 = load float, float* %19
store float %20, float* %6
%21 = icmp eq i32 %3, 1
br i1 %21, label %52, label %22
22: ; preds = %10
%23 = icmp eq i32 %4, 0
%24 = add nuw i32 %3, 1
%25 = zext i32 %24 to i64
br label %26
26: ; preds = %22, %47
%27 = phi float [ %20, %22 ], [ %48, %47 ]
%28 = phi float [ %20, %22 ], [ %49, %47 ]
%29 = phi i64 [ 2, %22 ], [ %50, %47 ]
%30 = getelementptr inbounds i32, i32* %2, i64 %29
%31 = load i32, i32* %30
%32 = add nsw i32 %31, 1
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds float, float* %16, i64 %33
%35 = load float, float* %34
br i1 %23, label %36, label %38
36: ; preds = %26
%37 = fsub float %35, %27
br label %42
38: ; preds = %26
%39 = tail call float @llvm.fabs.f32(float %35)
%40 = tail call float @llvm.fabs.f32(float %28)
%41 = fsub float %39, %40
br label %42
42: ; preds = %38, %36
%43 = phi float [ %27, %36 ], [ %28, %38 ]
%44 = phi float [ %37, %36 ], [ %41, %38 ]
%45 = fcmp ogt float %44, 0.000000e+00
br i1 %45, label %46, label %47
46: ; preds = %42
store float %35, float* %6
store i32 %31, i32* %5
br label %47
47: ; preds = %42, %46
%48 = phi float [ %27, %42 ], [ %35, %46 ]
%49 = phi float [ %43, %42 ], [ %35, %46 ]
%50 = add nuw nsw i64 %29, 1
%51 = icmp eq i64 %50, %25
br i1 %51, label %52, label %26
52: ; preds = %47, %10, %9
ret void
}