#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 */
int /*<<< orphan*/ memcpy(float *, float *, int);
void flip_layer(float *data, int rows, int cols, float missing_value) {
  int i, j;
  float temp[400 * 400];
  for (i = 0; i < rows; i++) {
    for (j = 0; j < cols; j++) {
      if (data[i * cols + j] == missing_value) {
        temp[j * rows + rows - i - 1] = 1.0e35;
      } else {
        temp[j * rows + rows - i - 1] = data[i * cols + j];
      }
    }
  }
  memcpy(data, temp, rows * cols * sizeof(float));
}


x86 assembly (clang, -O0):
<flip_layer>:
push   %rbp
mov    %rsp,%rbp
sub    $0x9c420,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11f5 <flip_layer+0xe5>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11e2 <flip_layer+0xd2>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x14(%rbp),%xmm0
jne    119e <flip_layer+0x8e>
jp     119e <flip_layer+0x8e>
mov    -0x1c(%rbp),%eax
imul   -0xc(%rbp),%eax
add    -0xc(%rbp),%eax
sub    -0x18(%rbp),%eax
sub    $0x1,%eax
cltq
movss  0xe70(%rip),%xmm0
movss  %xmm0,-0x9c420(%rbp,%rax,4)
f6 ff
jmp    11cf <flip_layer+0xbf>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x1c(%rbp),%eax
imul   -0xc(%rbp),%eax
add    -0xc(%rbp),%eax
sub    -0x18(%rbp),%eax
sub    $0x1,%eax
cltq
movss  %xmm0,-0x9c420(%rbp,%rax,4)
f6 ff
jmp    11d4 <flip_layer+0xc4>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1144 <flip_layer+0x34>
jmp    11e7 <flip_layer+0xd7>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1131 <flip_layer+0x21>
mov    -0x8(%rbp),%rdi
lea    -0x9c420(%rbp),%rsi
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
add    $0x9c420,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<flip_layer>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x9c468,%rsp
mov    %edx,%r14d
mov    %esi,%edx
mov    %rdi,0x8(%rsp)
test   %esi,%esi
jle    144d <flip_layer+0x33d>
movslq %r14d,%r13
mov    %edx,%eax
mov    %rax,0x58(%rsp)
mov    %r13d,%r9d
mov    %r9d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x30(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x28(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
cmp    $0x8,%r13d
setae  %al
cmp    $0x1,%edx
sete   %bl
and    %al,%bl
mov    %bl,0x3(%rsp)
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x18(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0x48(%rsp)
lea    (%rdx,%rdx,8),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
mov    %edx,%ebx
shl    $0x4,%ebx
mov    0x8(%rsp),%rax
lea    0x30(%rax),%rsi
lea    0x0(,%r13,4),%rcx
mov    %rcx,0x50(%rsp)
lea    -0x1(%rdx),%r10d
lea    (%rdx,%rdx,1),%r11d
movaps 0xe37(%rip),%xmm3
movss  0xe3e(%rip),%xmm8
lea    0x4(%rax),%r15
mov    $0xffffffff,%r8d
xor    %edi,%edi
mov    %rdx,0x40(%rsp)
mov    %r14d,0x14(%rsp)
mov    %r13,0x38(%rsp)
jmp    1217 <flip_layer+0x107>
nop
add    $0x1,%rdi
addl   $0xffffffff,0x4(%rsp)
mov    0x50(%rsp),%rax
add    %rax,%rsi
add    $0xffffffff,%r10d
add    $0xffffffff,%r8d
add    %rax,%r15
cmp    0x58(%rsp),%rdi
je     144d <flip_layer+0x33d>
test   %r14d,%r14d
jle    11f0 <flip_layer+0xe0>
mov    %rdi,%rbp
imul   %r13,%rbp
mov    %edi,%r12d
not    %r12d
add    %edx,%r12d
cmpb   $0x0,0x3(%rsp)
je     1300 <flip_layer+0x1f0>
cmpq   $0x0,0x28(%rsp)
je     1307 <flip_layer+0x1f7>
mov    0x18(%rsp),%rax
mov    %r10d,%r14d
mov    0x4(%rsp),%ecx
mov    %ecx,%edx
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%rsi,%r13,4),%xmm4
movups -0x20(%rsi,%r13,4),%xmm5
movaps %xmm4,%xmm6
cmpeqps %xmm1,%xmm6
movaps %xmm5,%xmm7
cmpeqps %xmm1,%xmm7
movslq %r14d,%r14
movaps %xmm3,%xmm2
andps  %xmm6,%xmm2
andnps %xmm4,%xmm6
orps   %xmm2,%xmm6
movaps %xmm3,%xmm2
andps  %xmm7,%xmm2
andnps %xmm5,%xmm7
orps   %xmm2,%xmm7
movups %xmm6,0x60(%rsp,%r14,4)
movups %xmm7,0x70(%rsp,%r14,4)
movups -0x10(%rsi,%r13,4),%xmm2
movups (%rsi,%r13,4),%xmm4
movaps %xmm2,%xmm5
cmpeqps %xmm1,%xmm5
movaps %xmm4,%xmm6
cmpeqps %xmm1,%xmm6
movslq %edx,%rdx
movaps %xmm3,%xmm7
andps  %xmm5,%xmm7
andnps %xmm2,%xmm5
orps   %xmm7,%xmm5
movaps %xmm3,%xmm2
andps  %xmm6,%xmm2
andnps %xmm4,%xmm6
orps   %xmm2,%xmm6
movups %xmm5,0x60(%rsp,%rdx,4)
movups %xmm6,0x70(%rsp,%rdx,4)
add    $0x10,%r13
add    %ebx,%edx
add    %ebx,%r14d
add    $0xfffffffffffffffe,%rax
jne    1260 <flip_layer+0x150>
jmp    130a <flip_layer+0x1fa>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbp,%rcx
xor    %ebp,%ebp
jmp    1382 <flip_layer+0x272>
xor    %r13d,%r13d
testb  $0x1,0x20(%rsp)
mov    0x40(%rsp),%rdx
je     1364 <flip_layer+0x254>
mov    %r13,%rax
add    %rbp,%rax
mov    0x8(%rsp),%rcx
movups (%rcx,%rax,4),%xmm2
movups 0x10(%rcx,%rax,4),%xmm4
movaps %xmm2,%xmm5
cmpeqps %xmm1,%xmm5
movaps %xmm4,%xmm6
cmpeqps %xmm1,%xmm6
imul   %edx,%r13d
add    %r12d,%r13d
movslq %r13d,%rax
movaps %xmm3,%xmm7
andps  %xmm5,%xmm7
andnps %xmm2,%xmm5
orps   %xmm7,%xmm5
movaps %xmm3,%xmm2
andps  %xmm6,%xmm2
andnps %xmm4,%xmm6
orps   %xmm2,%xmm6
movups %xmm5,0x60(%rsp,%rax,4)
movups %xmm6,0x70(%rsp,%rax,4)
mov    %rbp,%rcx
mov    0x30(%rsp),%rax
mov    %rax,%rbp
cmp    %r9,%rax
mov    0x14(%rsp),%r14d
mov    0x38(%rsp),%r13
je     11f0 <flip_layer+0xe0>
mov    %rbp,%rax
test   $0x1,%r9b
je     13c5 <flip_layer+0x2b5>
add    %rbp,%rcx
mov    0x8(%rsp),%rax
movss  (%rax,%rcx,4),%xmm2
mov    %ebp,%eax
imul   %edx,%eax
add    %eax,%r12d
movslq %r12d,%rax
movaps %xmm2,%xmm4
cmpeqss %xmm0,%xmm4
movaps %xmm4,%xmm5
andnps %xmm2,%xmm5
andps  %xmm8,%xmm4
orps   %xmm5,%xmm4
movss  %xmm4,0x60(%rsp,%rax,4)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    0x48(%rsp),%rbp
je     11f0 <flip_layer+0xe0>
lea    0x1(%rax),%ecx
imul   %edx,%ecx
add    %r8d,%ecx
lea    0x2(%rax),%ebp
imul   %edx,%ebp
add    %r8d,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%r15,%rax,4),%xmm2
movslq %ecx,%rcx
movaps %xmm2,%xmm4
cmpeqss %xmm0,%xmm4
movaps %xmm4,%xmm5
andnps %xmm2,%xmm5
andps  %xmm8,%xmm4
orps   %xmm5,%xmm4
movss  %xmm4,0x60(%rsp,%rcx,4)
movss  (%r15,%rax,4),%xmm2
movslq %ebp,%rbp
movaps %xmm2,%xmm4
cmpeqss %xmm0,%xmm4
movaps %xmm4,%xmm5
andnps %xmm2,%xmm5
andps  %xmm8,%xmm4
orps   %xmm5,%xmm4
movss  %xmm4,0x60(%rsp,%rbp,4)
add    $0x2,%rax
add    %r11d,%ecx
add    %r11d,%ebp
cmp    %rax,%r9
jne    13f0 <flip_layer+0x2e0>
jmp    11f0 <flip_layer+0xe0>
imul   %r14d,%edx
shl    $0x2,%edx
lea    0x60(%rsp),%rsi
mov    0x8(%rsp),%rdi
call   1030 <memcpy@plt>
add    $0x9c468,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @flip_layer(float* %0, i32 %1, i32 %2, float %3) {
%5 = alloca float*
%6 = alloca i32
%7 = alloca i32
%8 = alloca float
%9 = alloca i32
%10 = alloca i32
%11 = alloca [160000 x float]
store float* %0, float** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store float %3, float* %8
store i32 0, i32* %9
br label %12
12: ; preds = %69, %4
%13 = load i32, i32* %9
%14 = load i32, i32* %6
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %72
16: ; preds = %12
store i32 0, i32* %10
br label %17
17: ; preds = %65, %16
%18 = load i32, i32* %10
%19 = load i32, i32* %7
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %68
21: ; preds = %17
%22 = load float*, float** %5
%23 = load i32, i32* %9
%24 = load i32, i32* %7
%25 = mul nsw i32 %23, %24
%26 = load i32, i32* %10
%27 = add nsw i32 %25, %26
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds float, float* %22, i64 %28
%30 = load float, float* %29
%31 = load float, float* %8
%32 = fcmp oeq float %30, %31
br i1 %32, label %33, label %44
33: ; preds = %21
%34 = load i32, i32* %10
%35 = load i32, i32* %6
%36 = mul nsw i32 %34, %35
%37 = load i32, i32* %6
%38 = add nsw i32 %36, %37
%39 = load i32, i32* %9
%40 = sub nsw i32 %38, %39
%41 = sub nsw i32 %40, 1
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [160000 x float], [160000 x float]* %11, i64 0, i64 %42
store float 0x4733426180000000, float* %43
br label %64
44: ; preds = %21
%45 = load float*, float** %5
%46 = load i32, i32* %9
%47 = load i32, i32* %7
%48 = mul nsw i32 %46, %47
%49 = load i32, i32* %10
%50 = add nsw i32 %48, %49
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds float, float* %45, i64 %51
%53 = load float, float* %52
%54 = load i32, i32* %10
%55 = load i32, i32* %6
%56 = mul nsw i32 %54, %55
%57 = load i32, i32* %6
%58 = add nsw i32 %56, %57
%59 = load i32, i32* %9
%60 = sub nsw i32 %58, %59
%61 = sub nsw i32 %60, 1
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [160000 x float], [160000 x float]* %11, i64 0, i64 %62
store float %53, float* %63
br label %64
64: ; preds = %44, %33
br label %65
65: ; preds = %64
%66 = load i32, i32* %10
%67 = add nsw i32 %66, 1
store i32 %67, i32* %10
br label %17
68: ; preds = %17
br label %69
69: ; preds = %68
%70 = load i32, i32* %9
%71 = add nsw i32 %70, 1
store i32 %71, i32* %9
br label %12
72: ; preds = %12
%73 = load float*, float** %5
%74 = getelementptr inbounds [160000 x float], [160000 x float]* %11, i64 0, i64 0
%75 = load i32, i32* %6
%76 = load i32, i32* %7
%77 = mul nsw i32 %75, %76
%78 = sext i32 %77 to i64
%79 = mul i64 %78, 4
%80 = trunc i64 %79 to i32
%81 = call i32 @memcpy(float* %73, float* %74, i32 %80)
ret void
}

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