#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(char *, char *, unsigned long);
void copy_resize_2d(void *dest_2d, const void *src_2d,
                    unsigned short dest_width, unsigned short dest_height,
                    unsigned short src_width, unsigned short src_height,
                    unsigned short element_size) {
  char *dest = (char *)dest_2d;
  char *src = (char *)src_2d;
  unsigned long dest_rowsize = dest_width * element_size;
  unsigned long src_rowsize = src_width * element_size;
  unsigned long copy_rowsize = src_rowsize;
  if (dest_height > src_height)
    dest_height = src_height;
  if (copy_rowsize > dest_rowsize)
    copy_rowsize = dest_rowsize;
  for (; dest_height--; dest += dest_rowsize, src += src_rowsize)
    memcpy(dest, src, src_rowsize);
}


x86 assembly (clang, -O0):
<copy_resize_2d>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %r8d,-0x54(%rbp)
mov    %ecx,%eax
mov    -0x54(%rbp),%ecx
mov    %eax,-0x50(%rbp)
mov    %edx,%eax
mov    -0x50(%rbp),%edx
mov    %eax,-0x4c(%rbp)
mov    %rsi,%rax
mov    -0x4c(%rbp),%esi
mov    %rax,-0x48(%rbp)
mov    %rdi,%r8
mov    -0x48(%rbp),%rdi
mov    %r9w,%ax
mov    0x10(%rbp),%r9w
mov    %r8,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %si,-0x12(%rbp)
mov    %dx,-0x14(%rbp)
mov    %cx,-0x16(%rbp)
mov    %ax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
movzwl -0x12(%rbp),%eax
movzwl 0x10(%rbp),%ecx
imul   %ecx,%eax
cltq
mov    %rax,-0x30(%rbp)
movzwl -0x16(%rbp),%eax
movzwl 0x10(%rbp),%ecx
imul   %ecx,%eax
cltq
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
movzwl -0x14(%rbp),%eax
movzwl -0x18(%rbp),%ecx
cmp    %ecx,%eax
jle    11b0 <copy_resize_2d+0xa0>
mov    -0x18(%rbp),%ax
mov    %ax,-0x14(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x30(%rbp),%rax
jbe    11c6 <copy_resize_2d+0xb6>
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    11cb <copy_resize_2d+0xbb>
mov    -0x14(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x14(%rbp)
cmp    $0x0,%ax
je     1212 <copy_resize_2d+0x102>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x38(%rbp),%rdx
call   1030 <memcpy@plt>
mov    -0x30(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    11cb <copy_resize_2d+0xbb>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<copy_resize_2d>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %ecx,%r12d
cmp    %r9w,%r12w
cmova  %r9d,%r12d
test   %r12d,%r12d
je     116b <copy_resize_2d+0x5b>
mov    %r8d,%r15d
mov    %edx,%r14d
mov    %rsi,%rbx
mov    %rdi,%rbp
movzwl 0x30(%rsp),%eax
imul   %eax,%r14d
imul   %eax,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1030 <memcpy@plt>
add    %r14,%rbp
add    %r15,%rbx
add    $0xffff,%r12w
jne    1150 <copy_resize_2d+0x40>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @copy_resize_2d(i8* %0, i8* %1, i16 zeroext %2, i16 zeroext %3, i16 zeroext %4, i16 zeroext %5, i16 zeroext %6) {
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i16
%11 = alloca i16
%12 = alloca i16
%13 = alloca i16
%14 = alloca i16
%15 = alloca i8*
%16 = alloca i8*
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
store i8* %0, i8** %8
store i8* %1, i8** %9
store i16 %2, i16* %10
store i16 %3, i16* %11
store i16 %4, i16* %12
store i16 %5, i16* %13
store i16 %6, i16* %14
%20 = load i8*, i8** %8
store i8* %20, i8** %15
%21 = load i8*, i8** %9
store i8* %21, i8** %16
%22 = load i16, i16* %10
%23 = zext i16 %22 to i32
%24 = load i16, i16* %14
%25 = zext i16 %24 to i32
%26 = mul nsw i32 %23, %25
%27 = sext i32 %26 to i64
store i64 %27, i64* %17
%28 = load i16, i16* %12
%29 = zext i16 %28 to i32
%30 = load i16, i16* %14
%31 = zext i16 %30 to i32
%32 = mul nsw i32 %29, %31
%33 = sext i32 %32 to i64
store i64 %33, i64* %18
%34 = load i64, i64* %18
store i64 %34, i64* %19
%35 = load i16, i16* %11
%36 = zext i16 %35 to i32
%37 = load i16, i16* %13
%38 = zext i16 %37 to i32
%39 = icmp sgt i32 %36, %38
br i1 %39, label %40, label %42
40: ; preds = %7
%41 = load i16, i16* %13
store i16 %41, i16* %11
br label %42
42: ; preds = %40, %7
%43 = load i64, i64* %19
%44 = load i64, i64* %17
%45 = icmp ugt i64 %43, %44
br i1 %45, label %46, label %48
46: ; preds = %42
%47 = load i64, i64* %17
store i64 %47, i64* %19
br label %48
48: ; preds = %46, %42
br label %49
49: ; preds = %58, %48
%50 = load i16, i16* %11
%51 = add i16 %50, -1
store i16 %51, i16* %11
%52 = icmp ne i16 %50, 0
br i1 %52, label %53, label %65
53: ; preds = %49
%54 = load i8*, i8** %15
%55 = load i8*, i8** %16
%56 = load i64, i64* %18
%57 = call i32 @memcpy(i8* %54, i8* %55, i64 %56)
br label %58
58: ; preds = %53
%59 = load i64, i64* %17
%60 = load i8*, i8** %15
%61 = getelementptr inbounds i8, i8* %60, i64 %59
store i8* %61, i8** %15
%62 = load i64, i64* %18
%63 = load i8*, i8** %16
%64 = getelementptr inbounds i8, i8* %63, i64 %62
store i8* %64, i8** %16
br label %49
65: ; preds = %49
ret void
}

LLVM IR (-O2):
define void @copy_resize_2d(i8* %0, i8* %1, i16 zeroext %2, i16 zeroext %3, i16 zeroext %4, i16 zeroext %5, i16 zeroext %6) {
%8 = zext i16 %2 to i32
%9 = zext i16 %6 to i32
%10 = mul nuw nsw i32 %9, %8
%11 = zext i32 %10 to i64
%12 = zext i16 %4 to i32
%13 = mul nuw nsw i32 %9, %12
%14 = zext i32 %13 to i64
%15 = icmp ugt i16 %3, %5
%16 = select i1 %15, i16 %5, i16 %3
%17 = icmp eq i16 %16, 0
br i1 %17, label %27, label %18
18: ; preds = %7, %18
%19 = phi i16 [ %22, %18 ], [ %16, %7 ]
%20 = phi i8* [ %24, %18 ], [ %0, %7 ]
%21 = phi i8* [ %25, %18 ], [ %1, %7 ]
%22 = add i16 %19, -1
%23 = tail call i32 @memcpy(i8* %20, i8* %21, i64 %14)
%24 = getelementptr inbounds i8, i8* %20, i64 %11
%25 = getelementptr inbounds i8, i8* %21, i64 %14
%26 = icmp eq i16 %22, 0
br i1 %26, label %27, label %18
27: ; preds = %18, %7
ret void
}