void Array2Dexclcopy(double **src, double **dest, int m, int n, int excl_idx) {
  int i;
  int j;
  int current_dest_line = 0;
  for (i = 0; i < m; i++) {
    if (i != excl_idx) {
      for (j = 0; j < n; j++) {
        dest[current_dest_line][j] = src[i][j];
      }
      current_dest_line++;
    }
  }
}


x86 assembly (clang, -O0):
<Array2Dexclcopy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11a3 <Array2Dexclcopy+0xa3>
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     1190 <Array2Dexclcopy+0x90>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1187 <Array2Dexclcopy+0x87>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1143 <Array2Dexclcopy+0x43>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1195 <Array2Dexclcopy+0x95>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1124 <Array2Dexclcopy+0x24>
pop    %rbp
ret

x86 assembly (clang, -O2):
<Array2Dexclcopy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,-0x8(%rsp)
test   %edx,%edx
jle    1301 <Array2Dexclcopy+0x201>
mov    %r8d,%r8d
mov    %edx,%r12d
mov    %ecx,%r15d
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x10(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x18(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%r14d
and    $0x3,%r14d
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x28(%rsp)
mov    %r15d,%esi
and    $0x3,%esi
mov    %r14,-0x20(%rsp)
shl    $0x5,%r14
xor    %r11d,%r11d
xor    %r13d,%r13d
jmp    1181 <Array2Dexclcopy+0x81>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r13d
add    $0x1,%r11
cmp    %r12,%r11
je     1301 <Array2Dexclcopy+0x201>
cmp    %r8,%r11
je     1174 <Array2Dexclcopy+0x74>
test   %ecx,%ecx
jle    1170 <Array2Dexclcopy+0x70>
mov    (%rdi,%r11,8),%rbp
movslq %r13d,%rax
mov    -0x8(%rsp),%rdx
mov    (%rdx,%rax,8),%r10
cmp    $0x4,%ecx
jb     11bc <Array2Dexclcopy+0xbc>
lea    0x0(,%r15,8),%rax
add    %rbp,%rax
cmp    %rax,%r10
jae    1235 <Array2Dexclcopy+0x135>
lea    (%r10,%r15,8),%rax
cmp    %rax,%rbp
jae    1235 <Array2Dexclcopy+0x135>
xor    %r9d,%r9d
mov    %r9,%rax
not    %rax
add    %r15,%rax
test   %rsi,%rsi
je     11e7 <Array2Dexclcopy+0xe7>
mov    %rsi,%rbx
movsd  0x0(%rbp,%r9,8),%xmm0
movsd  %xmm0,(%r10,%r9,8)
add    $0x1,%r9
add    $0xffffffffffffffff,%rbx
jne    11d0 <Array2Dexclcopy+0xd0>
cmp    $0x3,%rax
jb     1170 <Array2Dexclcopy+0x70>
nopl   (%rax)
movsd  0x0(%rbp,%r9,8),%xmm0
movsd  %xmm0,(%r10,%r9,8)
movsd  0x8(%rbp,%r9,8),%xmm0
movsd  %xmm0,0x8(%r10,%r9,8)
movsd  0x10(%rbp,%r9,8),%xmm0
movsd  %xmm0,0x10(%r10,%r9,8)
movsd  0x18(%rbp,%r9,8),%xmm0
movsd  %xmm0,0x18(%r10,%r9,8)
add    $0x4,%r9
cmp    %r9,%r15
jne    11f0 <Array2Dexclcopy+0xf0>
jmp    1170 <Array2Dexclcopy+0x70>
cmpq   $0xc,-0x18(%rsp)
jae    1241 <Array2Dexclcopy+0x141>
xor    %ebx,%ebx
jmp    12b1 <Array2Dexclcopy+0x1b1>
mov    -0x28(%rsp),%rax
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rbx,8),%xmm0
movups 0x10(%rbp,%rbx,8),%xmm1
movups %xmm0,(%r10,%rbx,8)
movups %xmm1,0x10(%r10,%rbx,8)
movups 0x20(%rbp,%rbx,8),%xmm0
movups 0x30(%rbp,%rbx,8),%xmm1
movups %xmm0,0x20(%r10,%rbx,8)
movups %xmm1,0x30(%r10,%rbx,8)
movups 0x40(%rbp,%rbx,8),%xmm0
movups 0x50(%rbp,%rbx,8),%xmm1
movups %xmm0,0x40(%r10,%rbx,8)
movups %xmm1,0x50(%r10,%rbx,8)
movups 0x60(%rbp,%rbx,8),%xmm0
movups 0x70(%rbp,%rbx,8),%xmm1
movups %xmm0,0x60(%r10,%rbx,8)
movups %xmm1,0x70(%r10,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rax
jne    1250 <Array2Dexclcopy+0x150>
cmpq   $0x0,-0x20(%rsp)
je     12eb <Array2Dexclcopy+0x1eb>
lea    (%r10,%rbx,8),%rax
add    $0x10,%rax
lea    0x10(,%rbx,8),%rbx
add    %rbp,%rbx
xor    %edx,%edx
xchg   %ax,%ax
movups -0x10(%rbx,%rdx,1),%xmm0
movups (%rbx,%rdx,1),%xmm1
movups %xmm0,-0x10(%rax,%rdx,1)
movups %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r14
jne    12d0 <Array2Dexclcopy+0x1d0>
mov    -0x10(%rsp),%rax
mov    %rax,%r9
cmp    %r15,%rax
je     1170 <Array2Dexclcopy+0x70>
jmp    11bf <Array2Dexclcopy+0xbf>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @Array2Dexclcopy(double** %0, double** %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca double**
%7 = alloca double**
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
store double** %0, double*** %6
store double** %1, double*** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
store i32 0, i32* %13
store i32 0, i32* %11
br label %14
14: ; preds = %52, %5
%15 = load i32, i32* %11
%16 = load i32, i32* %8
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %55
18: ; preds = %14
%19 = load i32, i32* %11
%20 = load i32, i32* %10
%21 = icmp ne i32 %19, %20
br i1 %21, label %22, label %51
22: ; preds = %18
store i32 0, i32* %12
br label %23
23: ; preds = %45, %22
%24 = load i32, i32* %12
%25 = load i32, i32* %9
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %48
27: ; preds = %23
%28 = load double**, double*** %6
%29 = load i32, i32* %11
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds double*, double** %28, i64 %30
%32 = load double*, double** %31
%33 = load i32, i32* %12
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds double, double* %32, i64 %34
%36 = load double, double* %35
%37 = load double**, double*** %7
%38 = load i32, i32* %13
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double*, double** %37, i64 %39
%41 = load double*, double** %40
%42 = load i32, i32* %12
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %41, i64 %43
store double %36, double* %44
br label %45
45: ; preds = %27
%46 = load i32, i32* %12
%47 = add nsw i32 %46, 1
store i32 %47, i32* %12
br label %23
48: ; preds = %23
%49 = load i32, i32* %13
%50 = add nsw i32 %49, 1
store i32 %50, i32* %13
br label %51
51: ; preds = %48, %18
br label %52
52: ; preds = %51
%53 = load i32, i32* %11
%54 = add nsw i32 %53, 1
store i32 %54, i32* %11
br label %14
55: ; preds = %14
ret void
}

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