#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__ malloc(size_t);
int /*<<< orphan*/ nrerror(char *);
float **submatrix(float **a, int oldrl, int oldrh, int oldcl, int oldch,
                  int newrl, int newcl) {
  int i, j, nrow = oldrh - oldrl + 1, ncol = oldcl - newcl;
  float **m;
  m = (float **)malloc((size_t)((nrow + 1) * sizeof(float *)));
  if (!m)
    nrerror("allocation failure in submatrix()");
  m += 1;
  m -= newrl;
  for (i = oldrl, j = newrl; i <= oldrh; i++, j++)
    m[j] = a[i] + ncol;
  return m;
}


x86 assembly (clang, -O0):
<submatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    1182 <submatrix+0x62>
lea    0xe83(%rip),%rdi
call   1030 <nrerror@plt>
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     11fa <submatrix+0xda>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x2c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b4 <submatrix+0x94>
mov    -0x38(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<submatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r9d,%r13d
mov    %ecx,%r12d
mov    %edx,%r15d
mov    %esi,%ebp
mov    %rdi,%rbx
mov    %edx,%eax
sub    %esi,%eax
add    $0x2,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,%r14
test   %rax,%rax
jne    1160 <submatrix+0x40>
lea    0xea5(%rip),%rdi
call   1030 <nrerror@plt>
lea    0x8(%r14),%rcx
movslq %r13d,%r11
lea    0x0(,%r11,8),%rdx
mov    %rcx,%rax
sub    %rdx,%rax
mov    %r15d,%edi
sub    %ebp,%edi
jl     1357 <submatrix+0x237>
sub    0x40(%rsp),%r12d
movslq %r12d,%r12
movslq %ebp,%r10
cmp    $0x3,%edi
jb     11ba <submatrix+0x9a>
lea    (%r10,%rdi,1),%rdx
lea    (%rbx,%rdx,8),%rdx
add    $0x8,%rdx
cmp    %rdx,%rcx
jae    1280 <submatrix+0x160>
lea    (%r14,%rdi,8),%rcx
add    $0x10,%rcx
lea    (%rbx,%r10,8),%rdx
cmp    %rcx,%rdx
jae    1280 <submatrix+0x160>
mov    %r11,%r9
mov    %r15d,%r8d
sub    %r10d,%r8d
lea    0x1(%r8),%edx
and    $0x3,%edx
je     1213 <submatrix+0xf3>
mov    %r9,%rcx
sub    %r11,%rcx
lea    (%r14,%rcx,8),%r13
mov    %rbx,(%rsp)
lea    (%rbx,%r10,8),%rdi
neg    %edx
mov    $0x8,%ebx
xor    %ebp,%ebp
lea    0x0(,%r12,4),%rcx
nop
mov    -0x8(%rdi,%rbx,1),%rsi
add    %rcx,%rsi
mov    %rsi,0x0(%r13,%rbx,1)
add    $0xffffffffffffffff,%rbp
add    $0x8,%rbx
cmp    %ebp,%edx
jne    11f0 <submatrix+0xd0>
sub    %rbp,%r9
sub    %rbp,%r10
mov    (%rsp),%rbx
cmp    $0x3,%r8d
jb     1357 <submatrix+0x237>
sub    %r11,%r9
lea    (%r14,%r9,8),%rdx
add    $0x20,%rdx
sub    %r10d,%r15d
add    $0x1,%r15d
lea    (%rbx,%r10,8),%rsi
add    $0x18,%rsi
xor    %edi,%edi
shl    $0x2,%r12
nopl   (%rax)
mov    -0x18(%rsi,%rdi,8),%rcx
add    %r12,%rcx
mov    %rcx,-0x18(%rdx,%rdi,8)
mov    -0x10(%rsi,%rdi,8),%rcx
add    %r12,%rcx
mov    %rcx,-0x10(%rdx,%rdi,8)
mov    -0x8(%rsi,%rdi,8),%rcx
add    %r12,%rcx
mov    %rcx,-0x8(%rdx,%rdi,8)
mov    (%rsi,%rdi,8),%rcx
add    %r12,%rcx
mov    %rcx,(%rdx,%rdi,8)
add    $0x4,%rdi
cmp    %edi,%r15d
jne    1240 <submatrix+0x120>
jmp    1357 <submatrix+0x237>
add    $0x1,%rdi
mov    %rdi,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
movq   %r12,%xmm0
test   %rcx,%rcx
je     1372 <submatrix+0x252>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rbx,%r10,8),%rdx
add    $0x30,%rdx
xor    %ebp,%ebp
pshufd $0x44,%xmm0,%xmm1
psllq  $0x2,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x30(%rdx,%rbp,8),%xmm2
movdqu -0x20(%rdx,%rbp,8),%xmm3
paddq  %xmm1,%xmm2
paddq  %xmm1,%xmm3
movdqu %xmm2,0x8(%r14,%rbp,8)
movdqu %xmm3,0x18(%r14,%rbp,8)
movdqu -0x10(%rdx,%rbp,8),%xmm2
movdqu (%rdx,%rbp,8),%xmm3
paddq  %xmm1,%xmm2
paddq  %xmm1,%xmm3
movdqu %xmm2,0x28(%r14,%rbp,8)
movdqu %xmm3,0x38(%r14,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rsi
jne    12d0 <submatrix+0x1b0>
test   $0x1,%r9b
je     1352 <submatrix+0x232>
lea    (%r11,%rbp,1),%rcx
add    %r10,%rbp
movdqu (%rbx,%rbp,8),%xmm1
movdqu 0x10(%rbx,%rbp,8),%xmm2
pshufd $0x44,%xmm0,%xmm0
psllq  $0x2,%xmm0
paddq  %xmm0,%xmm1
paddq  %xmm2,%xmm0
movdqu %xmm1,(%rax,%rcx,8)
movdqu %xmm0,0x10(%rax,%rcx,8)
cmp    %r8,%rdi
jne    1366 <submatrix+0x246>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%r8,%r11,1),%r9
add    %r8,%r10
jmp    11bd <submatrix+0x9d>
xor    %ebp,%ebp
test   $0x1,%r9b
jne    1323 <submatrix+0x203>
jmp    1352 <submatrix+0x232>

LLVM IR (-O0):
@.str = [34 x i8] c"allocation failure in submatrix()\00"
define float** @submatrix(float** %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%8 = alloca float**
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = 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 i32 %6, i32* %14
%20 = load i32, i32* %10
%21 = load i32, i32* %9
%22 = sub nsw i32 %20, %21
%23 = add nsw i32 %22, 1
store i32 %23, i32* %17
%24 = load i32, i32* %11
%25 = load i32, i32* %14
%26 = sub nsw i32 %24, %25
store i32 %26, i32* %18
%27 = load i32, i32* %17
%28 = add nsw i32 %27, 1
%29 = sext i32 %28 to i64
%30 = mul i64 %29, 8
%31 = call i64 @malloc(i64 %30)
%32 = inttoptr i64 %31 to float**
store float** %32, float*** %19
%33 = load float**, float*** %19
%34 = icmp ne float** %33, null
br i1 %34, label %37, label %35
35: ; preds = %7
%36 = call i32 @nrerror(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0))
br label %37
37: ; preds = %35, %7
%38 = load float**, float*** %19
%39 = getelementptr inbounds float*, float** %38, i64 1
store float** %39, float*** %19
%40 = load i32, i32* %13
%41 = load float**, float*** %19
%42 = sext i32 %40 to i64
%43 = sub i64 0, %42
%44 = getelementptr inbounds float*, float** %41, i64 %43
store float** %44, float*** %19
%45 = load i32, i32* %9
store i32 %45, i32* %15
%46 = load i32, i32* %13
store i32 %46, i32* %16
br label %47
47: ; preds = %64, %37
%48 = load i32, i32* %15
%49 = load i32, i32* %10
%50 = icmp sle i32 %48, %49
br i1 %50, label %51, label %69
51: ; preds = %47
%52 = load float**, float*** %8
%53 = load i32, i32* %15
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds float*, float** %52, i64 %54
%56 = load float*, float** %55
%57 = load i32, i32* %18
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %56, i64 %58
%60 = load float**, float*** %19
%61 = load i32, i32* %16
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float*, float** %60, i64 %62
store float* %59, float** %63
br label %64
64: ; preds = %51
%65 = load i32, i32* %15
%66 = add nsw i32 %65, 1
store i32 %66, i32* %15
%67 = load i32, i32* %16
%68 = add nsw i32 %67, 1
store i32 %68, i32* %16
br label %47
69: ; preds = %47
%70 = load float**, float*** %19
ret float** %70
}

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