#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 */
double DBL_MAX;
double *malloc(int);
double *get_min_values(double **front, int frontlen, int vlen) {
  size_t i, j;
  double *min_values = malloc(sizeof(double) * vlen);
  for (i = 0; i < vlen; i++)
    min_values[i] = DBL_MAX;
  for (i = 0; i < frontlen; i++) {
    for (j = 0; j < vlen; j++) {
      if (front[i][j] < min_values[j]) {
        min_values[j] = front[i][j];
      }
    }
  }
  return min_values;
}


x86 assembly (clang, -O0):
<get_min_values>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x28(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x10(%rbp),%rcx
cmp    %rcx,%rax
jae    1177 <get_min_values+0x67>
mov    0x2e8b(%rip),%rax
movsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    113d <get_min_values+0x2d>
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jae    1223 <get_min_values+0x113>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
cmp    %rcx,%rax
jae    120d <get_min_values+0xfd>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    11f7 <get_min_values+0xe7>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    11fc <get_min_values+0xec>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1198 <get_min_values+0x88>
jmp    1212 <get_min_values+0x102>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    117f <get_min_values+0x6f>
mov    -0x28(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_min_values>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %edx,%r13d
mov    %esi,%r15d
mov    %rdi,%r14
movslq %edx,%r12
lea    0x0(,%r12,8),%edi
call   1030 <malloc@plt>
test   %r12d,%r12d
je     1264 <get_min_values+0x154>
mov    0x2e9c(%rip),%rcx
movsd  (%rcx),%xmm0
cmp    $0x2,%r12
mov    $0x1,%ecx
cmovae %r12,%rcx
cmp    $0x4,%rcx
jae    1162 <get_min_values+0x52>
xor    %edx,%edx
jmp    1256 <get_min_values+0x146>
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x7,%esi
cmp    $0x1c,%rbp
jae    1192 <get_min_values+0x82>
xor    %ebp,%ebp
jmp    1225 <get_min_values+0x115>
and    $0xfffffffffffffff8,%rdi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movupd %xmm1,(%rax,%rbp,8)
movupd %xmm1,0x10(%rax,%rbp,8)
movupd %xmm1,0x20(%rax,%rbp,8)
movupd %xmm1,0x30(%rax,%rbp,8)
movupd %xmm1,0x40(%rax,%rbp,8)
movupd %xmm1,0x50(%rax,%rbp,8)
movupd %xmm1,0x60(%rax,%rbp,8)
movupd %xmm1,0x70(%rax,%rbp,8)
movupd %xmm1,0x80(%rax,%rbp,8)
movupd %xmm1,0x90(%rax,%rbp,8)
movupd %xmm1,0xa0(%rax,%rbp,8)
movupd %xmm1,0xb0(%rax,%rbp,8)
movupd %xmm1,0xc0(%rax,%rbp,8)
movupd %xmm1,0xd0(%rax,%rbp,8)
movupd %xmm1,0xe0(%rax,%rbp,8)
movupd %xmm1,0xf0(%rax,%rbp,8)
add    $0x20,%rbp
add    $0xfffffffffffffff8,%rdi
jne    11a0 <get_min_values+0x90>
test   %rsi,%rsi
je     125f <get_min_values+0x14f>
lea    (%rax,%rbp,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movupd %xmm1,-0x10(%rdi,%rbp,1)
movupd %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    1240 <get_min_values+0x130>
jmp    125f <get_min_values+0x14f>
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1256 <get_min_values+0x146>
test   %r15d,%r15d
je     1309 <get_min_values+0x1f9>
cmp    $0x2,%r12
mov    $0x1,%ecx
cmovae %r12,%rcx
movslq %r15d,%rdx
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edi,%edi
jmp    1299 <get_min_values+0x189>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
cmp    %rdx,%rdi
je     1309 <get_min_values+0x1f9>
test   %r13d,%r13d
je     1290 <get_min_values+0x180>
mov    (%r14,%rdi,8),%rbp
xor    %ebx,%ebx
cmp    $0x1,%r13d
jne    12d9 <get_min_values+0x1c9>
test   $0x1,%cl
je     1290 <get_min_values+0x180>
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  (%rax,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    1290 <get_min_values+0x180>
movsd  %xmm0,(%rax,%rbx,8)
jmp    1290 <get_min_values+0x180>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rbx
cmp    %rbx,%rsi
je     12aa <get_min_values+0x19a>
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  (%rax,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    12ef <get_min_values+0x1df>
movsd  %xmm0,(%rax,%rbx,8)
movsd  0x8(%rbp,%rbx,8),%xmm0
movsd  0x8(%rax,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    12d0 <get_min_values+0x1c0>
movsd  %xmm0,0x8(%rax,%rbx,8)
jmp    12d0 <get_min_values+0x1c0>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@DBL_MAX = global double 0.000000e+00
define double* @get_min_values(double** %0, i32 %1, i32 %2) {
%4 = alloca double**
%5 = alloca i32
%6 = alloca i32
%7 = alloca i64
%8 = alloca i64
%9 = alloca double*
store double** %0, double*** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%10 = load i32, i32* %6
%11 = sext i32 %10 to i64
%12 = mul i64 8, %11
%13 = trunc i64 %12 to i32
%14 = call double* @malloc(i32 %13)
store double* %14, double** %9
store i64 0, i64* %7
br label %15
15: ; preds = %25, %3
%16 = load i64, i64* %7
%17 = load i32, i32* %6
%18 = sext i32 %17 to i64
%19 = icmp ult i64 %16, %18
br i1 %19, label %20, label %28
20: ; preds = %15
%21 = load double, double* @DBL_MAX
%22 = load double*, double** %9
%23 = load i64, i64* %7
%24 = getelementptr inbounds double, double* %22, i64 %23
store double %21, double* %24
br label %25
25: ; preds = %20
%26 = load i64, i64* %7
%27 = add i64 %26, 1
store i64 %27, i64* %7
br label %15
28: ; preds = %15
store i64 0, i64* %7
br label %29
29: ; preds = %69, %28
%30 = load i64, i64* %7
%31 = load i32, i32* %5
%32 = sext i32 %31 to i64
%33 = icmp ult i64 %30, %32
br i1 %33, label %34, label %72
34: ; preds = %29
store i64 0, i64* %8
br label %35
35: ; preds = %65, %34
%36 = load i64, i64* %8
%37 = load i32, i32* %6
%38 = sext i32 %37 to i64
%39 = icmp ult i64 %36, %38
br i1 %39, label %40, label %68
40: ; preds = %35
%41 = load double**, double*** %4
%42 = load i64, i64* %7
%43 = getelementptr inbounds double*, double** %41, i64 %42
%44 = load double*, double** %43
%45 = load i64, i64* %8
%46 = getelementptr inbounds double, double* %44, i64 %45
%47 = load double, double* %46
%48 = load double*, double** %9
%49 = load i64, i64* %8
%50 = getelementptr inbounds double, double* %48, i64 %49
%51 = load double, double* %50
%52 = fcmp olt double %47, %51
br i1 %52, label %53, label %64
53: ; preds = %40
%54 = load double**, double*** %4
%55 = load i64, i64* %7
%56 = getelementptr inbounds double*, double** %54, i64 %55
%57 = load double*, double** %56
%58 = load i64, i64* %8
%59 = getelementptr inbounds double, double* %57, i64 %58
%60 = load double, double* %59
%61 = load double*, double** %9
%62 = load i64, i64* %8
%63 = getelementptr inbounds double, double* %61, i64 %62
store double %60, double* %63
br label %64
64: ; preds = %53, %40
br label %65
65: ; preds = %64
%66 = load i64, i64* %8
%67 = add i64 %66, 1
store i64 %67, i64* %8
br label %35
68: ; preds = %35
br label %69
69: ; preds = %68
%70 = load i64, i64* %7
%71 = add i64 %70, 1
store i64 %71, i64* %7
br label %29
72: ; preds = %29
%73 = load double*, double** %9
ret double* %73
}

LLVM IR (-O2):
@DBL_MAX = global double 0.000000e+00
define noalias double* @get_min_values(double** nocapture %0, i32 %1, i32 %2) {
%4 = sext i32 %2 to i64
%5 = shl i32 %2, 3
%6 = tail call double* @malloc(i32 %5)
%7 = icmp eq i32 %2, 0
br i1 %7, label %87, label %8
8: ; preds = %3
%9 = load double, double* @DBL_MAX
%10 = call i64 @llvm.umax.i64(i64 %4, i64 1)
%11 = icmp ult i64 %10, 4
br i1 %11, label %85, label %12
12: ; preds = %8
%13 = and i64 %10, -4
%14 = insertelement <2 x double> poison, double %9, i64 0
%15 = shufflevector <2 x double> %14, <2 x double> poison, <2 x i32> zeroinitializer
%16 = insertelement <2 x double> poison, double %9, i64 0
%17 = shufflevector <2 x double> %16, <2 x double> poison, <2 x i32> zeroinitializer
%18 = add i64 %13, -4
%19 = lshr exact i64 %18, 2
%20 = add nuw nsw i64 %19, 1
%21 = and i64 %20, 7
%22 = icmp ult i64 %18, 28
br i1 %22, label %70, label %23
23: ; preds = %12
%24 = and i64 %20, 9223372036854775800
br label %25
25: ; preds = %25, %23
%26 = phi i64 [ 0, %23 ], [ %67, %25 ]
%27 = phi i64 [ 0, %23 ], [ %68, %25 ]
%28 = getelementptr inbounds double, double* %6, i64 %26
%29 = bitcast double* %28 to <2 x double>*
store <2 x double> %15, <2 x double>* %29
%30 = getelementptr inbounds double, double* %28, i64 2
%31 = bitcast double* %30 to <2 x double>*
store <2 x double> %17, <2 x double>* %31
%32 = or i64 %26, 4
%33 = getelementptr inbounds double, double* %6, i64 %32
%34 = bitcast double* %33 to <2 x double>*
store <2 x double> %15, <2 x double>* %34
%35 = getelementptr inbounds double, double* %33, i64 2
%36 = bitcast double* %35 to <2 x double>*
store <2 x double> %17, <2 x double>* %36
%37 = or i64 %26, 8
%38 = getelementptr inbounds double, double* %6, i64 %37
%39 = bitcast double* %38 to <2 x double>*
store <2 x double> %15, <2 x double>* %39
%40 = getelementptr inbounds double, double* %38, i64 2
%41 = bitcast double* %40 to <2 x double>*
store <2 x double> %17, <2 x double>* %41
%42 = or i64 %26, 12
%43 = getelementptr inbounds double, double* %6, i64 %42
%44 = bitcast double* %43 to <2 x double>*
store <2 x double> %15, <2 x double>* %44
%45 = getelementptr inbounds double, double* %43, i64 2
%46 = bitcast double* %45 to <2 x double>*
store <2 x double> %17, <2 x double>* %46
%47 = or i64 %26, 16
%48 = getelementptr inbounds double, double* %6, i64 %47
%49 = bitcast double* %48 to <2 x double>*
store <2 x double> %15, <2 x double>* %49
%50 = getelementptr inbounds double, double* %48, i64 2
%51 = bitcast double* %50 to <2 x double>*
store <2 x double> %17, <2 x double>* %51
%52 = or i64 %26, 20
%53 = getelementptr inbounds double, double* %6, i64 %52
%54 = bitcast double* %53 to <2 x double>*
store <2 x double> %15, <2 x double>* %54
%55 = getelementptr inbounds double, double* %53, i64 2
%56 = bitcast double* %55 to <2 x double>*
store <2 x double> %17, <2 x double>* %56
%57 = or i64 %26, 24
%58 = getelementptr inbounds double, double* %6, i64 %57
%59 = bitcast double* %58 to <2 x double>*
store <2 x double> %15, <2 x double>* %59
%60 = getelementptr inbounds double, double* %58, i64 2
%61 = bitcast double* %60 to <2 x double>*
store <2 x double> %17, <2 x double>* %61
%62 = or i64 %26, 28
%63 = getelementptr inbounds double, double* %6, i64 %62
%64 = bitcast double* %63 to <2 x double>*
store <2 x double> %15, <2 x double>* %64
%65 = getelementptr inbounds double, double* %63, i64 2
%66 = bitcast double* %65 to <2 x double>*
store <2 x double> %17, <2 x double>* %66
%67 = add nuw i64 %26, 32
%68 = add i64 %27, 8
%69 = icmp eq i64 %68, %24
br i1 %69, label %70, label %25
70: ; preds = %25, %12
%71 = phi i64 [ 0, %12 ], [ %67, %25 ]
%72 = icmp eq i64 %21, 0
br i1 %72, label %83, label %73
73: ; preds = %70, %73
%74 = phi i64 [ %80, %73 ], [ %71, %70 ]
%75 = phi i64 [ %81, %73 ], [ 0, %70 ]
%76 = getelementptr inbounds double, double* %6, i64 %74
%77 = bitcast double* %76 to <2 x double>*
store <2 x double> %15, <2 x double>* %77
%78 = getelementptr inbounds double, double* %76, i64 2
%79 = bitcast double* %78 to <2 x double>*
store <2 x double> %17, <2 x double>* %79
%80 = add nuw i64 %74, 4
%81 = add i64 %75, 1
%82 = icmp eq i64 %81, %21
br i1 %82, label %83, label %73
83: ; preds = %73, %70
%84 = icmp eq i64 %10, %13
br i1 %84, label %87, label %85
85: ; preds = %8, %83
%86 = phi i64 [ 0, %8 ], [ %13, %83 ]
br label %96
87: ; preds = %96, %83, %3
%88 = icmp eq i32 %1, 0
br i1 %88, label %139, label %89
89: ; preds = %87
%90 = call i64 @llvm.umax.i64(i64 %4, i64 1)
%91 = sext i32 %1 to i64
%92 = and i64 %90, 1
%93 = icmp eq i32 %2, 1
%94 = and i64 %90, -2
%95 = icmp eq i64 %92, 0
br label %101
96: ; preds = %85, %96
%97 = phi i64 [ %99, %96 ], [ %86, %85 ]
%98 = getelementptr inbounds double, double* %6, i64 %97
store double %9, double* %98
%99 = add nuw i64 %97, 1
%100 = icmp eq i64 %99, %10
br i1 %100, label %87, label %96
101: ; preds = %89, %136
%102 = phi i64 [ 0, %89 ], [ %137, %136 ]
br i1 %7, label %136, label %103
103: ; preds = %101
%104 = getelementptr inbounds double*, double** %0, i64 %102
%105 = load double*, double** %104
br i1 %93, label %127, label %106
106: ; preds = %103, %123
%107 = phi i64 [ %124, %123 ], [ 0, %103 ]
%108 = phi i64 [ %125, %123 ], [ 0, %103 ]
%109 = getelementptr inbounds double, double* %105, i64 %107
%110 = load double, double* %109
%111 = getelementptr inbounds double, double* %6, i64 %107
%112 = load double, double* %111
%113 = fcmp olt double %110, %112
br i1 %113, label %114, label %115
114: ; preds = %106
store double %110, double* %111
br label %115
115: ; preds = %106, %114
%116 = or i64 %107, 1
%117 = getelementptr inbounds double, double* %105, i64 %116
%118 = load double, double* %117
%119 = getelementptr inbounds double, double* %6, i64 %116
%120 = load double, double* %119
%121 = fcmp olt double %118, %120
br i1 %121, label %122, label %123
122: ; preds = %115
store double %118, double* %119
br label %123
123: ; preds = %122, %115
%124 = add nuw i64 %107, 2
%125 = add i64 %108, 2
%126 = icmp eq i64 %125, %94
br i1 %126, label %127, label %106
127: ; preds = %123, %103
%128 = phi i64 [ 0, %103 ], [ %124, %123 ]
br i1 %95, label %136, label %129
129: ; preds = %127
%130 = getelementptr inbounds double, double* %105, i64 %128
%131 = load double, double* %130
%132 = getelementptr inbounds double, double* %6, i64 %128
%133 = load double, double* %132
%134 = fcmp olt double %131, %133
br i1 %134, label %135, label %136
135: ; preds = %129
store double %131, double* %132
br label %136
136: ; preds = %127, %135, %129, %101
%137 = add nuw i64 %102, 1
%138 = icmp eq i64 %137, %91
br i1 %138, label %139, label %101
139: ; preds = %136, %87
ret double* %6
}