#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 */
void *malloc(size_t);
void *mdmalloc(size_t el_size, size_t n, size_t *d) {
  size_t i, j, k, ptr_space, arr_space, align_space, ptr_count, arr_count,
      count, step, next;
  void *zone, **ptr;
  if (el_size == 0) {
    return NULL;
  }
  if (n == 0)
    return malloc(el_size);
  for (arr_count = 1, ptr_count = 0, i = 0; i < n; i++) {
    if (d[i] == 0) {
      return NULL;
    }
    ptr_count += arr_count;
    arr_count *= d[i];
  }
  if (n == 1)
    return malloc(el_size * d[0]);
  ptr_count--;
  ptr_space = sizeof(void *) * ptr_count;
  arr_space = el_size * arr_count;
  if (ptr_space % el_size)
    align_space = el_size - (ptr_space % el_size);
  else
    align_space = 0;
  zone = malloc(ptr_space + align_space + arr_space);
  if (zone == NULL)
    return NULL;
  ptr = (void **)zone;
  for (k = 0, count = 1, i = 0; i < (n - 2); i++) {
    count *= d[i];
    step = d[i + 1];
    next = k + count;
    for (j = 0; j < count; j++, k++)
      ptr[k] = &ptr[next + j * step];
  }
  count *= d[n - 2];
  step = arr_space / count;
  for (j = 0; j < count; j++, k++)
    ptr[k] = (char *)zone + ptr_space + align_space + j * step;
  return zone;
}


x86 assembly (clang, -O0):
<mdmalloc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    113f <mdmalloc+0x2f>
movq   $0x0,-0x8(%rbp)
jmp    13fe <mdmalloc+0x2ee>
cmpq   $0x0,-0x18(%rbp)
jne    115c <mdmalloc+0x4c>
mov    -0x10(%rbp),%rdi
call   1030 <malloc@plt>
mov    %rax,-0x8(%rbp)
jmp    13fe <mdmalloc+0x2ee>
movq   $0x1,-0x60(%rbp)
movq   $0x0,-0x58(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    11d4 <mdmalloc+0xc4>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    11a2 <mdmalloc+0x92>
movq   $0x0,-0x8(%rbp)
jmp    13fe <mdmalloc+0x2ee>
mov    -0x60(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
imul   -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1174 <mdmalloc+0x64>
cmpq   $0x1,-0x18(%rbp)
jne    11f9 <mdmalloc+0xe9>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rax
imul   (%rax),%rdi
call   1030 <malloc@plt>
mov    %rax,-0x8(%rbp)
jmp    13fe <mdmalloc+0x2ee>
mov    -0x58(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
shl    $0x3,%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
imul   -0x60(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x10(%rbp)
cmp    $0x0,%rdx
je     125e <mdmalloc+0x14e>
mov    -0x10(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x40(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x10(%rbp)
mov    -0x90(%rbp),%rax
sub    %rdx,%rax
mov    %rax,-0x50(%rbp)
jmp    1266 <mdmalloc+0x156>
movq   $0x0,-0x50(%rbp)
mov    -0x40(%rbp),%rdi
add    -0x50(%rbp),%rdi
add    -0x48(%rbp),%rdi
call   1030 <malloc@plt>
mov    %rax,-0x80(%rbp)
cmpq   $0x0,-0x80(%rbp)
jne    1293 <mdmalloc+0x183>
movq   $0x0,-0x8(%rbp)
jmp    13fe <mdmalloc+0x2ee>
mov    -0x80(%rbp),%rax
mov    %rax,-0x88(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x1,-0x68(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jae    1373 <mdmalloc+0x263>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
imul   -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    %rax,-0x70(%rbp)
mov    -0x38(%rbp),%rax
add    -0x68(%rbp),%rax
mov    %rax,-0x78(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x68(%rbp),%rax
jae    135d <mdmalloc+0x24d>
mov    -0x88(%rbp),%rdx
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x70(%rbp),%rcx
add    %rcx,%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x88(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1305 <mdmalloc+0x1f5>
jmp    1362 <mdmalloc+0x252>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    12b6 <mdmalloc+0x1a6>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x2,%rcx
mov    (%rax,%rcx,8),%rax
imul   -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x68(%rbp)
mov    %rax,-0x70(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x68(%rbp),%rax
jae    13f6 <mdmalloc+0x2e6>
mov    -0x80(%rbp),%rdx
add    -0x40(%rbp),%rdx
add    -0x50(%rbp),%rdx
mov    -0x30(%rbp),%rax
imul   -0x70(%rbp),%rax
add    %rax,%rdx
mov    -0x88(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    13a4 <mdmalloc+0x294>
mov    -0x80(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mdmalloc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
test   %rdi,%rdi
je     14d9 <mdmalloc+0x3c9>
mov    %rsi,%r13
mov    %rdi,%rbp
test   %rsi,%rsi
je     1168 <mdmalloc+0x58>
mov    %rdx,%r12
mov    $0x1,%ebx
xor    %ecx,%ecx
xor    %edx,%edx
xor    %eax,%eax
mov    (%r12,%rdx,8),%rsi
test   %rsi,%rsi
je     14db <mdmalloc+0x3cb>
add    %rbx,%rax
imul   %rsi,%rbx
add    $0x1,%rdx
cmp    %rdx,%r13
jne    1140 <mdmalloc+0x30>
cmp    $0x1,%r13
jne    117e <mdmalloc+0x6e>
imul   (%r12),%rbp
mov    %rbp,%rdi
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <malloc@plt>
lea    -0x8(,%rax,8),%r14
ff
imul   %rbp,%rbx
mov    %r14,%rax
or     %rbp,%rax
shr    $0x20,%rax
je     11a0 <mdmalloc+0x90>
mov    %r14,%rax
xor    %edx,%edx
div    %rbp
jmp    11a7 <mdmalloc+0x97>
mov    %r14d,%eax
xor    %edx,%edx
div    %ebp
sub    %rdx,%rbp
test   %rdx,%rdx
cmove  %rdx,%rbp
lea    (%rbx,%r14,1),%rdi
add    %rbp,%rdi
call   1030 <malloc@plt>
test   %rax,%rax
je     14d9 <mdmalloc+0x3c9>
mov    %rax,%rcx
mov    %r13,%r8
add    $0xfffffffffffffffe,%r8
mov    %r14,0x10(%rsp)
mov    %rbp,0x8(%rsp)
je     14ed <mdmalloc+0x3dd>
mov    (%r12),%r15
lea    0x30(%rcx),%rax
mov    %rax,0x18(%rsp)
mov    $0x1,%r11d
xor    %eax,%eax
movdqa 0xe02(%rip),%xmm8
movdqa 0xe09(%rip),%xmm12
movq   %rcx,%xmm0
pshufd $0x44,%xmm0,%xmm13
movdqa 0xe05(%rip),%xmm9
movdqa 0xe0c(%rip),%xmm10
movdqa 0xe13(%rip),%xmm11
xor    %esi,%esi
mov    %r8,0x20(%rsp)
jmp    1249 <mdmalloc+0x139>
cs nopw 0x0(%rax,%rax,1)
cmp    %r8,%rax
je     14f5 <mdmalloc+0x3e5>
mov    %r11,%rdx
mov    %r15,%r11
imul   %rdx,%r11
mov    0x8(%r12,%rax,8),%r15
add    $0x1,%rax
test   %r11,%r11
je     1240 <mdmalloc+0x130>
lea    (%r11,%rsi,1),%r10
cmp    $0x4,%r11
jae    1280 <mdmalloc+0x170>
xor    %edx,%edx
jmp    148f <mdmalloc+0x37f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r11,%rdx
and    $0xfffffffffffffffc,%rdx
movq   %r15,%xmm0
pshufd $0x44,%xmm0,%xmm7
movq   %r10,%xmm0
pshufd $0x44,%xmm0,%xmm6
lea    -0x4(%rdx),%rdi
mov    %rdi,%r9
shr    $0x2,%r9
add    $0x1,%r9
movdqa %xmm7,%xmm3
psrlq  $0x20,%xmm3
test   %rdi,%rdi
je     14c6 <mdmalloc+0x3b6>
mov    %r9,%r8
and    $0xfffffffffffffffe,%r8
mov    0x18(%rsp),%rdi
lea    (%rdi,%rsi,8),%r14
xor    %ebp,%ebp
movdqa %xmm8,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa %xmm1,%xmm5
paddq  %xmm12,%xmm5
movdqa %xmm1,%xmm0
psrlq  $0x20,%xmm0
pmuludq %xmm7,%xmm0
movdqa %xmm1,%xmm4
pmuludq %xmm3,%xmm4
paddq  %xmm0,%xmm4
psllq  $0x20,%xmm4
movdqa %xmm1,%xmm0
pmuludq %xmm7,%xmm0
paddq  %xmm4,%xmm0
movdqa %xmm5,%xmm2
pmuludq %xmm3,%xmm2
movdqa %xmm5,%xmm4
psrlq  $0x20,%xmm4
pmuludq %xmm7,%xmm4
paddq  %xmm2,%xmm4
psllq  $0x20,%xmm4
pmuludq %xmm7,%xmm5
paddq  %xmm4,%xmm5
paddq  %xmm6,%xmm0
paddq  %xmm6,%xmm5
psllq  $0x3,%xmm0
paddq  %xmm13,%xmm0
psllq  $0x3,%xmm5
paddq  %xmm13,%xmm5
movdqu %xmm0,-0x30(%r14,%rbp,8)
movdqu %xmm5,-0x20(%r14,%rbp,8)
movdqa %xmm1,%xmm4
paddq  %xmm9,%xmm4
movdqa %xmm1,%xmm0
paddq  %xmm10,%xmm0
movdqa %xmm4,%xmm2
pmuludq %xmm3,%xmm2
movdqa %xmm4,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm7,%xmm5
paddq  %xmm2,%xmm5
psllq  $0x20,%xmm5
pmuludq %xmm7,%xmm4
paddq  %xmm5,%xmm4
movdqa %xmm0,%xmm2
pmuludq %xmm3,%xmm2
movdqa %xmm0,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm7,%xmm5
paddq  %xmm2,%xmm5
psllq  $0x20,%xmm5
pmuludq %xmm7,%xmm0
paddq  %xmm5,%xmm0
paddq  %xmm6,%xmm4
paddq  %xmm6,%xmm0
psllq  $0x3,%xmm4
paddq  %xmm13,%xmm4
psllq  $0x3,%xmm0
paddq  %xmm13,%xmm0
movdqu %xmm4,-0x10(%r14,%rbp,8)
movdqu %xmm0,(%r14,%rbp,8)
add    $0x8,%rbp
paddq  %xmm11,%xmm1
add    $0xfffffffffffffffe,%r8
jne    12e0 <mdmalloc+0x1d0>
test   $0x1,%r9b
je     147e <mdmalloc+0x36e>
movdqa %xmm1,%xmm4
paddq  %xmm12,%xmm4
add    %rsi,%rbp
movdqa %xmm1,%xmm0
psrlq  $0x20,%xmm0
pmuludq %xmm7,%xmm0
movdqa %xmm1,%xmm2
pmuludq %xmm3,%xmm2
paddq  %xmm0,%xmm2
psllq  $0x20,%xmm2
pmuludq %xmm7,%xmm1
paddq  %xmm2,%xmm1
pmuludq %xmm4,%xmm3
movdqa %xmm4,%xmm0
psrlq  $0x20,%xmm0
pmuludq %xmm7,%xmm0
paddq  %xmm3,%xmm0
psllq  $0x20,%xmm0
pmuludq %xmm7,%xmm4
paddq  %xmm0,%xmm4
paddq  %xmm6,%xmm1
paddq  %xmm6,%xmm4
psllq  $0x3,%xmm1
paddq  %xmm13,%xmm1
psllq  $0x3,%xmm4
paddq  %xmm13,%xmm4
movdqu %xmm1,(%rcx,%rbp,8)
movdqu %xmm4,0x10(%rcx,%rbp,8)
add    %rdx,%rsi
cmp    %rdx,%r11
mov    0x20(%rsp),%r8
je     1240 <mdmalloc+0x130>
mov    %r11,%rdi
sub    %rdx,%rdi
imul   %r15,%rdx
add    %rdx,%r10
lea    (%rcx,%r10,8),%rdx
lea    0x0(,%r15,8),%rbp
nopl   0x0(%rax,%rax,1)
mov    %rdx,(%rcx,%rsi,8)
add    $0x1,%rsi
add    %rbp,%rdx
add    $0xffffffffffffffff,%rdi
jne    14b0 <mdmalloc+0x3a0>
jmp    1240 <mdmalloc+0x130>
xor    %ebp,%ebp
movdqa %xmm8,%xmm1
test   $0x1,%r9b
jne    1403 <mdmalloc+0x2f3>
jmp    147e <mdmalloc+0x36e>
xor    %ecx,%ecx
mov    %rcx,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
mov    $0x1,%r11d
imul   -0x10(%r12,%r13,8),%r11
mov    %rbx,%rax
or     %r11,%rax
shr    $0x20,%rax
je     1511 <mdmalloc+0x401>
mov    %rbx,%rax
xor    %edx,%edx
div    %r11
jmp    1518 <mdmalloc+0x408>
mov    %ebx,%eax
xor    %edx,%edx
div    %r11d
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%rdx
test   %r11,%r11
je     14db <mdmalloc+0x3cb>
add    %rcx,%r9
add    %rdx,%r9
lea    -0x1(%r11),%rdi
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rdi
jae    1542 <mdmalloc+0x432>
xor    %edx,%edx
jmp    15a3 <mdmalloc+0x493>
and    $0xfffffffffffffffc,%r11
lea    (%rcx,%rsi,8),%rbx
add    $0x18,%rbx
xor    %edx,%edx
mov    %rdx,%rdi
imul   %rax,%rdi
add    %r9,%rdi
mov    %rdi,-0x18(%rbx,%rdx,8)
mov    %rdx,%rdi
or     $0x1,%rdi
imul   %rax,%rdi
add    %r9,%rdi
mov    %rdi,-0x10(%rbx,%rdx,8)
mov    %rdx,%rdi
or     $0x2,%rdi
imul   %rax,%rdi
add    %r9,%rdi
mov    %rdi,-0x8(%rbx,%rdx,8)
mov    %rdx,%rdi
or     $0x3,%rdi
imul   %rax,%rdi
add    %r9,%rdi
mov    %rdi,(%rbx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r11
jne    1550 <mdmalloc+0x440>
add    %rdx,%rsi
test   %r8,%r8
je     14db <mdmalloc+0x3cb>
lea    (%rcx,%rsi,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdx,%rbp
imul   %rax,%rbp
add    %r9,%rbp
mov    %rbp,(%rsi,%rdi,8)
add    $0x1,%rdx
add    $0x1,%rdi
cmp    %rdi,%r8
jne    15c0 <mdmalloc+0x4b0>
jmp    14db <mdmalloc+0x3cb>

LLVM IR (-O0):
define i8* @mdmalloc(i64 %0, i64 %1, i64* %2) {
%4 = alloca i8*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64*
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i8*
%20 = alloca i8**
store i64 %0, i64* %5
store i64 %1, i64* %6
store i64* %2, i64** %7
%21 = load i64, i64* %5
%22 = icmp eq i64 %21, 0
br i1 %22, label %23, label %24
23: ; preds = %3
store i8* null, i8** %4
br label %177
24: ; preds = %3
%25 = load i64, i64* %6
%26 = icmp eq i64 %25, 0
br i1 %26, label %27, label %30
27: ; preds = %24
%28 = load i64, i64* %5
%29 = call i8* @malloc(i64 %28)
store i8* %29, i8** %4
br label %177
30: ; preds = %24
store i64 1, i64* %15
store i64 0, i64* %14
store i64 0, i64* %8
br label %31
31: ; preds = %52, %30
%32 = load i64, i64* %8
%33 = load i64, i64* %6
%34 = icmp ult i64 %32, %33
br i1 %34, label %35, label %55
35: ; preds = %31
%36 = load i64*, i64** %7
%37 = load i64, i64* %8
%38 = getelementptr inbounds i64, i64* %36, i64 %37
%39 = load i64, i64* %38
%40 = icmp eq i64 %39, 0
br i1 %40, label %41, label %42
41: ; preds = %35
store i8* null, i8** %4
br label %177
42: ; preds = %35
%43 = load i64, i64* %15
%44 = load i64, i64* %14
%45 = add i64 %44, %43
store i64 %45, i64* %14
%46 = load i64*, i64** %7
%47 = load i64, i64* %8
%48 = getelementptr inbounds i64, i64* %46, i64 %47
%49 = load i64, i64* %48
%50 = load i64, i64* %15
%51 = mul i64 %50, %49
store i64 %51, i64* %15
br label %52
52: ; preds = %42
%53 = load i64, i64* %8
%54 = add i64 %53, 1
store i64 %54, i64* %8
br label %31
55: ; preds = %31
%56 = load i64, i64* %6
%57 = icmp eq i64 %56, 1
br i1 %57, label %58, label %65
58: ; preds = %55
%59 = load i64, i64* %5
%60 = load i64*, i64** %7
%61 = getelementptr inbounds i64, i64* %60, i64 0
%62 = load i64, i64* %61
%63 = mul i64 %59, %62
%64 = call i8* @malloc(i64 %63)
store i8* %64, i8** %4
br label %177
65: ; preds = %55
%66 = load i64, i64* %14
%67 = add i64 %66, -1
store i64 %67, i64* %14
%68 = load i64, i64* %14
%69 = mul i64 8, %68
store i64 %69, i64* %11
%70 = load i64, i64* %5
%71 = load i64, i64* %15
%72 = mul i64 %70, %71
store i64 %72, i64* %12
%73 = load i64, i64* %11
%74 = load i64, i64* %5
%75 = urem i64 %73, %74
%76 = icmp ne i64 %75, 0
br i1 %76, label %77, label %83
77: ; preds = %65
%78 = load i64, i64* %5
%79 = load i64, i64* %11
%80 = load i64, i64* %5
%81 = urem i64 %79, %80
%82 = sub i64 %78, %81
store i64 %82, i64* %13
br label %84
83: ; preds = %65
store i64 0, i64* %13
br label %84
84: ; preds = %83, %77
%85 = load i64, i64* %11
%86 = load i64, i64* %13
%87 = add i64 %85, %86
%88 = load i64, i64* %12
%89 = add i64 %87, %88
%90 = call i8* @malloc(i64 %89)
store i8* %90, i8** %19
%91 = load i8*, i8** %19
%92 = icmp eq i8* %91, null
br i1 %92, label %93, label %94
93: ; preds = %84
store i8* null, i8** %4
br label %177
94: ; preds = %84
%95 = load i8*, i8** %19
%96 = bitcast i8* %95 to i8**
store i8** %96, i8*** %20
store i64 0, i64* %10
store i64 1, i64* %16
store i64 0, i64* %8
br label %97
97: ; preds = %139, %94
%98 = load i64, i64* %8
%99 = load i64, i64* %6
%100 = sub i64 %99, 2
%101 = icmp ult i64 %98, %100
br i1 %101, label %102, label %142
102: ; preds = %97
%103 = load i64*, i64** %7
%104 = load i64, i64* %8
%105 = getelementptr inbounds i64, i64* %103, i64 %104
%106 = load i64, i64* %105
%107 = load i64, i64* %16
%108 = mul i64 %107, %106
store i64 %108, i64* %16
%109 = load i64*, i64** %7
%110 = load i64, i64* %8
%111 = add i64 %110, 1
%112 = getelementptr inbounds i64, i64* %109, i64 %111
%113 = load i64, i64* %112
store i64 %113, i64* %17
%114 = load i64, i64* %10
%115 = load i64, i64* %16
%116 = add i64 %114, %115
store i64 %116, i64* %18
store i64 0, i64* %9
br label %117
117: ; preds = %133, %102
%118 = load i64, i64* %9
%119 = load i64, i64* %16
%120 = icmp ult i64 %118, %119
br i1 %120, label %121, label %138
121: ; preds = %117
%122 = load i8**, i8*** %20
%123 = load i64, i64* %18
%124 = load i64, i64* %9
%125 = load i64, i64* %17
%126 = mul i64 %124, %125
%127 = add i64 %123, %126
%128 = getelementptr inbounds i8*, i8** %122, i64 %127
%129 = bitcast i8** %128 to i8*
%130 = load i8**, i8*** %20
%131 = load i64, i64* %10
%132 = getelementptr inbounds i8*, i8** %130, i64 %131
store i8* %129, i8** %132
br label %133
133: ; preds = %121
%134 = load i64, i64* %9
%135 = add i64 %134, 1
store i64 %135, i64* %9
%136 = load i64, i64* %10
%137 = add i64 %136, 1
store i64 %137, i64* %10
br label %117
138: ; preds = %117
br label %139
139: ; preds = %138
%140 = load i64, i64* %8
%141 = add i64 %140, 1
store i64 %141, i64* %8
br label %97
142: ; preds = %97
%143 = load i64*, i64** %7
%144 = load i64, i64* %6
%145 = sub i64 %144, 2
%146 = getelementptr inbounds i64, i64* %143, i64 %145
%147 = load i64, i64* %146
%148 = load i64, i64* %16
%149 = mul i64 %148, %147
store i64 %149, i64* %16
%150 = load i64, i64* %12
%151 = load i64, i64* %16
%152 = udiv i64 %150, %151
store i64 %152, i64* %17
store i64 0, i64* %9
br label %153
153: ; preds = %170, %142
%154 = load i64, i64* %9
%155 = load i64, i64* %16
%156 = icmp ult i64 %154, %155
br i1 %156, label %157, label %175
157: ; preds = %153
%158 = load i8*, i8** %19
%159 = load i64, i64* %11
%160 = getelementptr inbounds i8, i8* %158, i64 %159
%161 = load i64, i64* %13
%162 = getelementptr inbounds i8, i8* %160, i64 %161
%163 = load i64, i64* %9
%164 = load i64, i64* %17
%165 = mul i64 %163, %164
%166 = getelementptr inbounds i8, i8* %162, i64 %165
%167 = load i8**, i8*** %20
%168 = load i64, i64* %10
%169 = getelementptr inbounds i8*, i8** %167, i64 %168
store i8* %166, i8** %169
br label %170
170: ; preds = %157
%171 = load i64, i64* %9
%172 = add i64 %171, 1
store i64 %172, i64* %9
%173 = load i64, i64* %10
%174 = add i64 %173, 1
store i64 %174, i64* %10
br label %153
175: ; preds = %153
%176 = load i8*, i8** %19
store i8* %176, i8** %4
br label %177
177: ; preds = %175, %93, %58, %41, %27, %23
%178 = load i8*, i8** %4
ret i8* %178
}

LLVM IR (-O2):
define i8* @mdmalloc(i64 %0, i64 %1, i64* nocapture %2) {
%4 = icmp eq i64 %0, 0
br i1 %4, label %203, label %5
5: ; preds = %3
%6 = icmp eq i64 %1, 0
br i1 %6, label %185, label %7
7: ; preds = %5, %14
%8 = phi i64 [ %17, %14 ], [ 0, %5 ]
%9 = phi i64 [ %16, %14 ], [ 1, %5 ]
%10 = phi i64 [ %15, %14 ], [ 0, %5 ]
%11 = getelementptr inbounds i64, i64* %2, i64 %8
%12 = load i64, i64* %11
%13 = icmp eq i64 %12, 0
br i1 %13, label %203, label %14
14: ; preds = %7
%15 = add i64 %9, %10
%16 = mul i64 %12, %9
%17 = add nuw i64 %8, 1
%18 = icmp eq i64 %17, %1
br i1 %18, label %19, label %7
19: ; preds = %14
%20 = shl i64 %15, 3
%21 = add i64 %20, -8
%22 = icmp eq i64 %1, 1
br i1 %22, label %23, label %26
23: ; preds = %19
%24 = load i64, i64* %2
%25 = mul i64 %24, %0
br label %185
26: ; preds = %19
%27 = mul i64 %16, %0
%28 = urem i64 %21, %0
%29 = icmp eq i64 %28, 0
%30 = sub i64 %0, %28
%31 = select i1 %29, i64 0, i64 %30
%32 = add i64 %27, %21
%33 = add i64 %32, %31
%34 = tail call i8* @malloc(i64 %33)
%35 = icmp eq i8* %34, null
br i1 %35, label %203, label %36
36: ; preds = %26
%37 = bitcast i8* %34 to i8**
%38 = add i64 %1, -2
%39 = icmp eq i64 %38, 0
br i1 %39, label %143, label %40
40: ; preds = %36
%41 = load i64, i64* %2
br label %45
42: ; preds = %132, %127, %45
%43 = phi i64 [ %49, %45 ], [ %60, %127 ], [ %141, %132 ]
%44 = icmp eq i64 %51, %38
br i1 %44, label %143, label %45
45: ; preds = %40, %42
%46 = phi i64 [ %53, %42 ], [ %41, %40 ]
%47 = phi i64 [ %51, %42 ], [ 0, %40 ]
%48 = phi i64 [ %50, %42 ], [ 1, %40 ]
%49 = phi i64 [ %43, %42 ], [ 0, %40 ]
%50 = mul i64 %46, %48
%51 = add nuw i64 %47, 1
%52 = getelementptr inbounds i64, i64* %2, i64 %51
%53 = load i64, i64* %52
%54 = add i64 %50, %49
%55 = icmp eq i64 %50, 0
br i1 %55, label %42, label %56
56: ; preds = %45
%57 = icmp ult i64 %50, 4
br i1 %57, label %129, label %58
58: ; preds = %56
%59 = and i64 %50, -4
%60 = add i64 %49, %59
%61 = insertelement <2 x i64> poison, i64 %53, i64 0
%62 = shufflevector <2 x i64> %61, <2 x i64> poison, <2 x i32> zeroinitializer
%63 = insertelement <2 x i64> poison, i64 %53, i64 0
%64 = shufflevector <2 x i64> %63, <2 x i64> poison, <2 x i32> zeroinitializer
%65 = insertelement <2 x i64> poison, i64 %54, i64 0
%66 = shufflevector <2 x i64> %65, <2 x i64> poison, <2 x i32> zeroinitializer
%67 = insertelement <2 x i64> poison, i64 %54, i64 0
%68 = shufflevector <2 x i64> %67, <2 x i64> poison, <2 x i32> zeroinitializer
%69 = add i64 %59, -4
%70 = lshr exact i64 %69, 2
%71 = add nuw nsw i64 %70, 1
%72 = and i64 %71, 1
%73 = icmp eq i64 %69, 0
br i1 %73, label %110, label %74
74: ; preds = %58
%75 = and i64 %71, 9223372036854775806
br label %76
76: ; preds = %76, %74
%77 = phi i64 [ 0, %74 ], [ %106, %76 ]
%78 = phi <2 x i64> [ <i64 0, i64 1>, %74 ], [ %107, %76 ]
%79 = phi i64 [ 0, %74 ], [ %108, %76 ]
%80 = add <2 x i64> %78, <i64 2, i64 2>
%81 = add i64 %49, %77
%82 = mul <2 x i64> %78, %62
%83 = mul <2 x i64> %80, %64
%84 = add <2 x i64> %66, %82
%85 = add <2 x i64> %68, %83
%86 = getelementptr inbounds i8*, i8** %37, <2 x i64> %84
%87 = getelementptr inbounds i8*, i8** %37, <2 x i64> %85
%88 = getelementptr inbounds i8*, i8** %37, i64 %81
%89 = bitcast i8** %88 to <2 x i8**>*
store <2 x i8**> %86, <2 x i8**>* %89
%90 = getelementptr inbounds i8*, i8** %88, i64 2
%91 = bitcast i8** %90 to <2 x i8**>*
store <2 x i8**> %87, <2 x i8**>* %91
%92 = or i64 %77, 4
%93 = add <2 x i64> %78, <i64 4, i64 4>
%94 = add <2 x i64> %78, <i64 6, i64 6>
%95 = add i64 %49, %92
%96 = mul <2 x i64> %93, %62
%97 = mul <2 x i64> %94, %64
%98 = add <2 x i64> %66, %96
%99 = add <2 x i64> %68, %97
%100 = getelementptr inbounds i8*, i8** %37, <2 x i64> %98
%101 = getelementptr inbounds i8*, i8** %37, <2 x i64> %99
%102 = getelementptr inbounds i8*, i8** %37, i64 %95
%103 = bitcast i8** %102 to <2 x i8**>*
store <2 x i8**> %100, <2 x i8**>* %103
%104 = getelementptr inbounds i8*, i8** %102, i64 2
%105 = bitcast i8** %104 to <2 x i8**>*
store <2 x i8**> %101, <2 x i8**>* %105
%106 = add nuw i64 %77, 8
%107 = add <2 x i64> %78, <i64 8, i64 8>
%108 = add i64 %79, 2
%109 = icmp eq i64 %108, %75
br i1 %109, label %110, label %76
110: ; preds = %76, %58
%111 = phi i64 [ 0, %58 ], [ %106, %76 ]
%112 = phi <2 x i64> [ <i64 0, i64 1>, %58 ], [ %107, %76 ]
%113 = icmp eq i64 %72, 0
br i1 %113, label %127, label %114
114: ; preds = %110
%115 = add <2 x i64> %112, <i64 2, i64 2>
%116 = add i64 %49, %111
%117 = mul <2 x i64> %112, %62
%118 = mul <2 x i64> %115, %64
%119 = add <2 x i64> %66, %117
%120 = add <2 x i64> %68, %118
%121 = getelementptr inbounds i8*, i8** %37, <2 x i64> %119
%122 = getelementptr inbounds i8*, i8** %37, <2 x i64> %120
%123 = getelementptr inbounds i8*, i8** %37, i64 %116
%124 = bitcast i8** %123 to <2 x i8**>*
store <2 x i8**> %121, <2 x i8**>* %124
%125 = getelementptr inbounds i8*, i8** %123, i64 2
%126 = bitcast i8** %125 to <2 x i8**>*
store <2 x i8**> %122, <2 x i8**>* %126
br label %127
127: ; preds = %110, %114
%128 = icmp eq i64 %50, %59
br i1 %128, label %42, label %129
129: ; preds = %56, %127
%130 = phi i64 [ 0, %56 ], [ %59, %127 ]
%131 = phi i64 [ %49, %56 ], [ %60, %127 ]
br label %132
132: ; preds = %129, %132
%133 = phi i64 [ %140, %132 ], [ %130, %129 ]
%134 = phi i64 [ %141, %132 ], [ %131, %129 ]
%135 = mul i64 %133, %53
%136 = add i64 %54, %135
%137 = getelementptr inbounds i8*, i8** %37, i64 %136
%138 = getelementptr inbounds i8*, i8** %37, i64 %134
%139 = bitcast i8** %138 to i8***
store i8** %137, i8*** %139
%140 = add nuw i64 %133, 1
%141 = add i64 %134, 1
%142 = icmp eq i64 %140, %50
br i1 %142, label %42, label %132
143: ; preds = %42, %36
%144 = phi i64 [ 0, %36 ], [ %43, %42 ]
%145 = phi i64 [ 1, %36 ], [ %50, %42 ]
%146 = getelementptr inbounds i64, i64* %2, i64 %38
%147 = load i64, i64* %146
%148 = mul i64 %147, %145
%149 = udiv i64 %27, %148
%150 = icmp eq i64 %148, 0
br i1 %150, label %203, label %151
151: ; preds = %143
%152 = getelementptr inbounds i8, i8* %34, i64 %21
%153 = getelementptr inbounds i8, i8* %152, i64 %31
%154 = add i64 %148, -1
%155 = and i64 %148, 3
%156 = icmp ult i64 %154, 3
br i1 %156, label %188, label %157
157: ; preds = %151
%158 = and i64 %148, -4
br label %159
159: ; preds = %159, %157
%160 = phi i64 [ 0, %157 ], [ %181, %159 ]
%161 = phi i64 [ %144, %157 ], [ %182, %159 ]
%162 = phi i64 [ 0, %157 ], [ %183, %159 ]
%163 = mul i64 %160, %149
%164 = getelementptr inbounds i8, i8* %153, i64 %163
%165 = getelementptr inbounds i8*, i8** %37, i64 %161
store i8* %164, i8** %165
%166 = or i64 %160, 1
%167 = add i64 %161, 1
%168 = mul i64 %166, %149
%169 = getelementptr inbounds i8, i8* %153, i64 %168
%170 = getelementptr inbounds i8*, i8** %37, i64 %167
store i8* %169, i8** %170
%171 = or i64 %160, 2
%172 = add i64 %161, 2
%173 = mul i64 %171, %149
%174 = getelementptr inbounds i8, i8* %153, i64 %173
%175 = getelementptr inbounds i8*, i8** %37, i64 %172
store i8* %174, i8** %175
%176 = or i64 %160, 3
%177 = add i64 %161, 3
%178 = mul i64 %176, %149
%179 = getelementptr inbounds i8, i8* %153, i64 %178
%180 = getelementptr inbounds i8*, i8** %37, i64 %177
store i8* %179, i8** %180
%181 = add nuw i64 %160, 4
%182 = add i64 %161, 4
%183 = add i64 %162, 4
%184 = icmp eq i64 %183, %158
br i1 %184, label %188, label %159
185: ; preds = %5, %23
%186 = phi i64 [ %25, %23 ], [ %0, %5 ]
%187 = tail call i8* @malloc(i64 %186)
br label %203
188: ; preds = %159, %151
%189 = phi i64 [ 0, %151 ], [ %181, %159 ]
%190 = phi i64 [ %144, %151 ], [ %182, %159 ]
%191 = icmp eq i64 %155, 0
br i1 %191, label %203, label %192
192: ; preds = %188, %192
%193 = phi i64 [ %199, %192 ], [ %189, %188 ]
%194 = phi i64 [ %200, %192 ], [ %190, %188 ]
%195 = phi i64 [ %201, %192 ], [ 0, %188 ]
%196 = mul i64 %193, %149
%197 = getelementptr inbounds i8, i8* %153, i64 %196
%198 = getelementptr inbounds i8*, i8** %37, i64 %194
store i8* %197, i8** %198
%199 = add nuw i64 %193, 1
%200 = add i64 %194, 1
%201 = add i64 %195, 1
%202 = icmp eq i64 %201, %155
br i1 %202, label %203, label %192
203: ; preds = %7, %188, %192, %185, %143, %26, %3
%204 = phi i8* [ null, %3 ], [ null, %26 ], [ %34, %143 ], [ %187, %185 ], [ %34, %192 ], [ %34, %188 ], [ null, %7 ]
ret i8* %204
}