#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 */
typedef int /*<<< orphan*/ uint16_t;
typedef int src_horizontal;
typedef int int32_t;
typedef int /*<<< orphan*/ int16_t;

/* Variables and functions */
int /*<<< orphan*/ memcpy(int /*<<< orphan*/ *, int /*<<< orphan*/ *, int);
void copy_hd_to_8k(uint16_t *dst, int16_t *src) {
  int32_t dst_horizontal = 8192;
  int32_t dst_vertical = 4320;
  int32_t src_horizontal = 1920;
  int32_t src_vertical = 1080;
  for (int j = 0; j < src_vertical; j++) {
    memcpy(dst + (j * dst_horizontal), src + (j * src_horizontal),
           src_horizontal * 2);
    memcpy(dst + (j * dst_horizontal) + src_horizontal,
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (j * dst_horizontal) + src_horizontal + src_horizontal,
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (j * dst_horizontal) + src_horizontal + src_horizontal +
               src_horizontal,
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (((dst_horizontal / 4) * src_vertical) * 4) +
               (j * dst_horizontal),
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (((dst_horizontal / 4) * src_vertical) * 4) +
               (j * dst_horizontal) + (src_horizontal),
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (((dst_horizontal / 4) * src_vertical) * 4) +
               (j * dst_horizontal) + (src_horizontal) + (src_horizontal),
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (((dst_horizontal / 4) * src_vertical) * 4) +
               (j * dst_horizontal) + (src_horizontal) + (src_horizontal) +
               (src_horizontal),
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (((dst_horizontal / 4) * src_vertical) * 8) +
               (j * dst_horizontal),
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (((dst_horizontal / 4) * src_vertical) * 8) +
               (j * dst_horizontal) + (src_horizontal),
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (((dst_horizontal / 4) * src_vertical) * 8) +
               (j * dst_horizontal) + (src_horizontal) + (src_horizontal),
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (((dst_horizontal / 4) * src_vertical) * 8) +
               (j * dst_horizontal) + (src_horizontal) + (src_horizontal) +
               (src_horizontal),
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (((dst_horizontal / 4) * src_vertical) * 12) +
               (j * dst_horizontal),
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (((dst_horizontal / 4) * src_vertical) * 12) +
               (j * dst_horizontal) + (src_horizontal),
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (((dst_horizontal / 4) * src_vertical) * 12) +
               (j * dst_horizontal) + (src_horizontal) + (src_horizontal),
           src + (j * src_horizontal), src_horizontal * 2);
    memcpy(dst + (((dst_horizontal / 4) * src_vertical) * 12) +
               (j * dst_horizontal) + (src_horizontal) + (src_horizontal) +
               (src_horizontal),
           src + (j * src_horizontal), src_horizontal * 2);
  }
  return;
}


x86 assembly (clang, -O0):
<copy_hd_to_8k>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x2000,-0x14(%rbp)
movl   $0x10e0,-0x18(%rbp)
movl   $0x780,-0x1c(%rbp)
movl   $0x438,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    16d9 <copy_hd_to_8k+0x5c9>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
imul   -0x20(%rbp),%eax
shl    $0x2,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
imul   -0x20(%rbp),%eax
shl    $0x2,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
imul   -0x20(%rbp),%eax
shl    $0x2,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
imul   -0x20(%rbp),%eax
shl    $0x2,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
imul   -0x20(%rbp),%eax
shl    $0x3,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
imul   -0x20(%rbp),%eax
shl    $0x3,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
imul   -0x20(%rbp),%eax
shl    $0x3,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
imul   -0x20(%rbp),%eax
shl    $0x3,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
imul   -0x20(%rbp),%eax
imul   $0xc,%eax,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
imul   -0x20(%rbp),%eax
imul   $0xc,%eax,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
imul   -0x20(%rbp),%eax
imul   $0xc,%eax,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
imul   -0x20(%rbp),%eax
imul   $0xc,%eax,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
call   1030 <memcpy@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1143 <copy_hd_to_8k+0x33>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<copy_hd_to_8k>:
push   %r15
push   %r14
push   %rbx
mov    %rsi,%r15
mov    %rdi,%r14
xor    %ebx,%ebx
nopl   (%rax)
lea    (%r14,%rbx,1),%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x1e00,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x3c00,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x5a00,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x21c0000,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x21c1e00,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x21c3c00,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x21c5a00,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x4380000,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x4381e00,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x4383c00,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x4385a00,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x6540000,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x6541e00,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x6543c00,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
lea    (%r14,%rbx,1),%rdi
add    $0x6545a00,%rdi
mov    %r15,%rsi
mov    $0xf00,%edx
call   1030 <memcpy@plt>
add    $0x1e00,%r15
add    $0x8000,%rbx
cmp    $0x21c0000,%rbx
jne    1120 <copy_hd_to_8k+0x10>
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @copy_hd_to_8k(i32* %0, i32* %1) {
%3 = alloca i32*
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i32* %0, i32** %3
store i32* %1, i32** %4
store i32 8192, i32* %5
store i32 4320, i32* %6
store i32 1920, i32* %7
store i32 1080, i32* %8
store i32 0, i32* %9
br label %10
10: ; preds = %411, %2
%11 = load i32, i32* %9
%12 = load i32, i32* %8
%13 = icmp slt i32 %11, %12
br i1 %13, label %14, label %414
14: ; preds = %10
%15 = load i32*, i32** %3
%16 = load i32, i32* %9
%17 = load i32, i32* %5
%18 = mul nsw i32 %16, %17
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i32, i32* %15, i64 %19
%21 = load i32*, i32** %4
%22 = load i32, i32* %9
%23 = load i32, i32* %7
%24 = mul nsw i32 %22, %23
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i32, i32* %21, i64 %25
%27 = load i32, i32* %7
%28 = mul nsw i32 %27, 2
%29 = call i32 @memcpy(i32* %20, i32* %26, i32 %28)
%30 = load i32*, i32** %3
%31 = load i32, i32* %9
%32 = load i32, i32* %5
%33 = mul nsw i32 %31, %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %30, i64 %34
%36 = load i32, i32* %7
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i32, i32* %35, i64 %37
%39 = load i32*, i32** %4
%40 = load i32, i32* %9
%41 = load i32, i32* %7
%42 = mul nsw i32 %40, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i32, i32* %39, i64 %43
%45 = load i32, i32* %7
%46 = mul nsw i32 %45, 2
%47 = call i32 @memcpy(i32* %38, i32* %44, i32 %46)
%48 = load i32*, i32** %3
%49 = load i32, i32* %9
%50 = load i32, i32* %5
%51 = mul nsw i32 %49, %50
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i32, i32* %48, i64 %52
%54 = load i32, i32* %7
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i32, i32* %53, i64 %55
%57 = load i32, i32* %7
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i32, i32* %56, i64 %58
%60 = load i32*, i32** %4
%61 = load i32, i32* %9
%62 = load i32, i32* %7
%63 = mul nsw i32 %61, %62
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i32, i32* %60, i64 %64
%66 = load i32, i32* %7
%67 = mul nsw i32 %66, 2
%68 = call i32 @memcpy(i32* %59, i32* %65, i32 %67)
%69 = load i32*, i32** %3
%70 = load i32, i32* %9
%71 = load i32, i32* %5
%72 = mul nsw i32 %70, %71
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %69, i64 %73
%75 = load i32, i32* %7
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i32, i32* %74, i64 %76
%78 = load i32, i32* %7
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %77, i64 %79
%81 = load i32, i32* %7
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i32, i32* %80, i64 %82
%84 = load i32*, i32** %4
%85 = load i32, i32* %9
%86 = load i32, i32* %7
%87 = mul nsw i32 %85, %86
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i32, i32* %84, i64 %88
%90 = load i32, i32* %7
%91 = mul nsw i32 %90, 2
%92 = call i32 @memcpy(i32* %83, i32* %89, i32 %91)
%93 = load i32*, i32** %3
%94 = load i32, i32* %5
%95 = sdiv i32 %94, 4
%96 = load i32, i32* %8
%97 = mul nsw i32 %95, %96
%98 = mul nsw i32 %97, 4
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %93, i64 %99
%101 = load i32, i32* %9
%102 = load i32, i32* %5
%103 = mul nsw i32 %101, %102
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i32, i32* %100, i64 %104
%106 = load i32*, i32** %4
%107 = load i32, i32* %9
%108 = load i32, i32* %7
%109 = mul nsw i32 %107, %108
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i32, i32* %106, i64 %110
%112 = load i32, i32* %7
%113 = mul nsw i32 %112, 2
%114 = call i32 @memcpy(i32* %105, i32* %111, i32 %113)
%115 = load i32*, i32** %3
%116 = load i32, i32* %5
%117 = sdiv i32 %116, 4
%118 = load i32, i32* %8
%119 = mul nsw i32 %117, %118
%120 = mul nsw i32 %119, 4
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i32, i32* %115, i64 %121
%123 = load i32, i32* %9
%124 = load i32, i32* %5
%125 = mul nsw i32 %123, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i32, i32* %122, i64 %126
%128 = load i32, i32* %7
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i32, i32* %127, i64 %129
%131 = load i32*, i32** %4
%132 = load i32, i32* %9
%133 = load i32, i32* %7
%134 = mul nsw i32 %132, %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %131, i64 %135
%137 = load i32, i32* %7
%138 = mul nsw i32 %137, 2
%139 = call i32 @memcpy(i32* %130, i32* %136, i32 %138)
%140 = load i32*, i32** %3
%141 = load i32, i32* %5
%142 = sdiv i32 %141, 4
%143 = load i32, i32* %8
%144 = mul nsw i32 %142, %143
%145 = mul nsw i32 %144, 4
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i32, i32* %140, i64 %146
%148 = load i32, i32* %9
%149 = load i32, i32* %5
%150 = mul nsw i32 %148, %149
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i32, i32* %147, i64 %151
%153 = load i32, i32* %7
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds i32, i32* %152, i64 %154
%156 = load i32, i32* %7
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i32, i32* %155, i64 %157
%159 = load i32*, i32** %4
%160 = load i32, i32* %9
%161 = load i32, i32* %7
%162 = mul nsw i32 %160, %161
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i32, i32* %159, i64 %163
%165 = load i32, i32* %7
%166 = mul nsw i32 %165, 2
%167 = call i32 @memcpy(i32* %158, i32* %164, i32 %166)
%168 = load i32*, i32** %3
%169 = load i32, i32* %5
%170 = sdiv i32 %169, 4
%171 = load i32, i32* %8
%172 = mul nsw i32 %170, %171
%173 = mul nsw i32 %172, 4
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i32, i32* %168, i64 %174
%176 = load i32, i32* %9
%177 = load i32, i32* %5
%178 = mul nsw i32 %176, %177
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i32, i32* %175, i64 %179
%181 = load i32, i32* %7
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i32, i32* %180, i64 %182
%184 = load i32, i32* %7
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i32, i32* %183, i64 %185
%187 = load i32, i32* %7
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i32, i32* %186, i64 %188
%190 = load i32*, i32** %4
%191 = load i32, i32* %9
%192 = load i32, i32* %7
%193 = mul nsw i32 %191, %192
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i32, i32* %190, i64 %194
%196 = load i32, i32* %7
%197 = mul nsw i32 %196, 2
%198 = call i32 @memcpy(i32* %189, i32* %195, i32 %197)
%199 = load i32*, i32** %3
%200 = load i32, i32* %5
%201 = sdiv i32 %200, 4
%202 = load i32, i32* %8
%203 = mul nsw i32 %201, %202
%204 = mul nsw i32 %203, 8
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i32, i32* %199, i64 %205
%207 = load i32, i32* %9
%208 = load i32, i32* %5
%209 = mul nsw i32 %207, %208
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i32, i32* %206, i64 %210
%212 = load i32*, i32** %4
%213 = load i32, i32* %9
%214 = load i32, i32* %7
%215 = mul nsw i32 %213, %214
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds i32, i32* %212, i64 %216
%218 = load i32, i32* %7
%219 = mul nsw i32 %218, 2
%220 = call i32 @memcpy(i32* %211, i32* %217, i32 %219)
%221 = load i32*, i32** %3
%222 = load i32, i32* %5
%223 = sdiv i32 %222, 4
%224 = load i32, i32* %8
%225 = mul nsw i32 %223, %224
%226 = mul nsw i32 %225, 8
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds i32, i32* %221, i64 %227
%229 = load i32, i32* %9
%230 = load i32, i32* %5
%231 = mul nsw i32 %229, %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i32, i32* %228, i64 %232
%234 = load i32, i32* %7
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds i32, i32* %233, i64 %235
%237 = load i32*, i32** %4
%238 = load i32, i32* %9
%239 = load i32, i32* %7
%240 = mul nsw i32 %238, %239
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i32, i32* %237, i64 %241
%243 = load i32, i32* %7
%244 = mul nsw i32 %243, 2
%245 = call i32 @memcpy(i32* %236, i32* %242, i32 %244)
%246 = load i32*, i32** %3
%247 = load i32, i32* %5
%248 = sdiv i32 %247, 4
%249 = load i32, i32* %8
%250 = mul nsw i32 %248, %249
%251 = mul nsw i32 %250, 8
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i32, i32* %246, i64 %252
%254 = load i32, i32* %9
%255 = load i32, i32* %5
%256 = mul nsw i32 %254, %255
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i32, i32* %253, i64 %257
%259 = load i32, i32* %7
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds i32, i32* %258, i64 %260
%262 = load i32, i32* %7
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i32, i32* %261, i64 %263
%265 = load i32*, i32** %4
%266 = load i32, i32* %9
%267 = load i32, i32* %7
%268 = mul nsw i32 %266, %267
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds i32, i32* %265, i64 %269
%271 = load i32, i32* %7
%272 = mul nsw i32 %271, 2
%273 = call i32 @memcpy(i32* %264, i32* %270, i32 %272)
%274 = load i32*, i32** %3
%275 = load i32, i32* %5
%276 = sdiv i32 %275, 4
%277 = load i32, i32* %8
%278 = mul nsw i32 %276, %277
%279 = mul nsw i32 %278, 8
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i32, i32* %274, i64 %280
%282 = load i32, i32* %9
%283 = load i32, i32* %5
%284 = mul nsw i32 %282, %283
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i32, i32* %281, i64 %285
%287 = load i32, i32* %7
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds i32, i32* %286, i64 %288
%290 = load i32, i32* %7
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds i32, i32* %289, i64 %291
%293 = load i32, i32* %7
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds i32, i32* %292, i64 %294
%296 = load i32*, i32** %4
%297 = load i32, i32* %9
%298 = load i32, i32* %7
%299 = mul nsw i32 %297, %298
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds i32, i32* %296, i64 %300
%302 = load i32, i32* %7
%303 = mul nsw i32 %302, 2
%304 = call i32 @memcpy(i32* %295, i32* %301, i32 %303)
%305 = load i32*, i32** %3
%306 = load i32, i32* %5
%307 = sdiv i32 %306, 4
%308 = load i32, i32* %8
%309 = mul nsw i32 %307, %308
%310 = mul nsw i32 %309, 12
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds i32, i32* %305, i64 %311
%313 = load i32, i32* %9
%314 = load i32, i32* %5
%315 = mul nsw i32 %313, %314
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds i32, i32* %312, i64 %316
%318 = load i32*, i32** %4
%319 = load i32, i32* %9
%320 = load i32, i32* %7
%321 = mul nsw i32 %319, %320
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds i32, i32* %318, i64 %322
%324 = load i32, i32* %7
%325 = mul nsw i32 %324, 2
%326 = call i32 @memcpy(i32* %317, i32* %323, i32 %325)
%327 = load i32*, i32** %3
%328 = load i32, i32* %5
%329 = sdiv i32 %328, 4
%330 = load i32, i32* %8
%331 = mul nsw i32 %329, %330
%332 = mul nsw i32 %331, 12
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds i32, i32* %327, i64 %333
%335 = load i32, i32* %9
%336 = load i32, i32* %5
%337 = mul nsw i32 %335, %336
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds i32, i32* %334, i64 %338
%340 = load i32, i32* %7
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i32, i32* %339, i64 %341
%343 = load i32*, i32** %4
%344 = load i32, i32* %9
%345 = load i32, i32* %7
%346 = mul nsw i32 %344, %345
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds i32, i32* %343, i64 %347
%349 = load i32, i32* %7
%350 = mul nsw i32 %349, 2
%351 = call i32 @memcpy(i32* %342, i32* %348, i32 %350)
%352 = load i32*, i32** %3
%353 = load i32, i32* %5
%354 = sdiv i32 %353, 4
%355 = load i32, i32* %8
%356 = mul nsw i32 %354, %355
%357 = mul nsw i32 %356, 12
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds i32, i32* %352, i64 %358
%360 = load i32, i32* %9
%361 = load i32, i32* %5
%362 = mul nsw i32 %360, %361
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds i32, i32* %359, i64 %363
%365 = load i32, i32* %7
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds i32, i32* %364, i64 %366
%368 = load i32, i32* %7
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds i32, i32* %367, i64 %369
%371 = load i32*, i32** %4
%372 = load i32, i32* %9
%373 = load i32, i32* %7
%374 = mul nsw i32 %372, %373
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds i32, i32* %371, i64 %375
%377 = load i32, i32* %7
%378 = mul nsw i32 %377, 2
%379 = call i32 @memcpy(i32* %370, i32* %376, i32 %378)
%380 = load i32*, i32** %3
%381 = load i32, i32* %5
%382 = sdiv i32 %381, 4
%383 = load i32, i32* %8
%384 = mul nsw i32 %382, %383
%385 = mul nsw i32 %384, 12
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i32, i32* %380, i64 %386
%388 = load i32, i32* %9
%389 = load i32, i32* %5
%390 = mul nsw i32 %388, %389
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i32, i32* %387, i64 %391
%393 = load i32, i32* %7
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds i32, i32* %392, i64 %394
%396 = load i32, i32* %7
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds i32, i32* %395, i64 %397
%399 = load i32, i32* %7
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds i32, i32* %398, i64 %400
%402 = load i32*, i32** %4
%403 = load i32, i32* %9
%404 = load i32, i32* %7
%405 = mul nsw i32 %403, %404
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds i32, i32* %402, i64 %406
%408 = load i32, i32* %7
%409 = mul nsw i32 %408, 2
%410 = call i32 @memcpy(i32* %401, i32* %407, i32 %409)
br label %411
411: ; preds = %14
%412 = load i32, i32* %9
%413 = add nsw i32 %412, 1
store i32 %413, i32* %9
br label %10
414: ; preds = %10
ret void
}

LLVM IR (-O2):
define void @copy_hd_to_8k(i32* %0, i32* %1) {
%3 = getelementptr inbounds i32, i32* %0, i64 8847360
%4 = getelementptr inbounds i32, i32* %0, i64 17694720
%5 = getelementptr inbounds i32, i32* %0, i64 26542080
br label %7
6: ; preds = %7
ret void
7: ; preds = %2, %7
%8 = phi i64 [ 0, %2 ], [ %44, %7 ]
%9 = shl nuw nsw i64 %8, 13
%10 = getelementptr inbounds i32, i32* %0, i64 %9
%11 = mul nuw nsw i64 %8, 1920
%12 = getelementptr inbounds i32, i32* %1, i64 %11
%13 = tail call i32 @memcpy(i32* %10, i32* %12, i32 3840)
%14 = getelementptr inbounds i32, i32* %10, i64 1920
%15 = tail call i32 @memcpy(i32* %14, i32* %12, i32 3840)
%16 = getelementptr inbounds i32, i32* %14, i64 1920
%17 = tail call i32 @memcpy(i32* %16, i32* %12, i32 3840)
%18 = getelementptr inbounds i32, i32* %16, i64 1920
%19 = tail call i32 @memcpy(i32* %18, i32* %12, i32 3840)
%20 = getelementptr inbounds i32, i32* %3, i64 %9
%21 = tail call i32 @memcpy(i32* %20, i32* %12, i32 3840)
%22 = getelementptr inbounds i32, i32* %20, i64 1920
%23 = tail call i32 @memcpy(i32* %22, i32* %12, i32 3840)
%24 = getelementptr inbounds i32, i32* %22, i64 1920
%25 = tail call i32 @memcpy(i32* %24, i32* %12, i32 3840)
%26 = getelementptr inbounds i32, i32* %24, i64 1920
%27 = tail call i32 @memcpy(i32* %26, i32* %12, i32 3840)
%28 = getelementptr inbounds i32, i32* %4, i64 %9
%29 = tail call i32 @memcpy(i32* %28, i32* %12, i32 3840)
%30 = getelementptr inbounds i32, i32* %28, i64 1920
%31 = tail call i32 @memcpy(i32* %30, i32* %12, i32 3840)
%32 = getelementptr inbounds i32, i32* %30, i64 1920
%33 = tail call i32 @memcpy(i32* %32, i32* %12, i32 3840)
%34 = getelementptr inbounds i32, i32* %32, i64 1920
%35 = tail call i32 @memcpy(i32* %34, i32* %12, i32 3840)
%36 = getelementptr inbounds i32, i32* %5, i64 %9
%37 = tail call i32 @memcpy(i32* %36, i32* %12, i32 3840)
%38 = getelementptr inbounds i32, i32* %36, i64 1920
%39 = tail call i32 @memcpy(i32* %38, i32* %12, i32 3840)
%40 = getelementptr inbounds i32, i32* %38, i64 1920
%41 = tail call i32 @memcpy(i32* %40, i32* %12, i32 3840)
%42 = getelementptr inbounds i32, i32* %40, i64 1920
%43 = tail call i32 @memcpy(i32* %42, i32* %12, i32 3840)
%44 = add nuw nsw i64 %8, 1
%45 = icmp eq i64 %44, 1080
br i1 %45, label %6, label %7
}