#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*/ assert(size_t *);
int /*<<< orphan*/ free(size_t *);
size_t *malloc(size_t const);
int /*<<< orphan*/ printf(char *, size_t, ...);
size_t *realloc(size_t *, size_t const);
int main(int argc, char *argv[]) {
  int *v = NULL;
  (void)argc;
  (void)argv;
  do {
    size_t cv_cap = ((v) ? ((size_t *)(v))[-1] : (size_t)0);
    if (cv_cap <= ((v) ? ((size_t *)(v))[-2] : (size_t)0)) {
      do {
        const size_t cv_sz =
            (!cv_cap ? cv_cap + 1 : cv_cap * 2) * sizeof(*((v))) +
            (sizeof(size_t) * 2);
        if (!((v))) {
          size_t *cv_p = malloc(cv_sz);
          assert(cv_p);
          ((v)) = (void *)(&cv_p[2]);
          do {
            if (((v))) {
              ((size_t *)(((v))))[-1] = ((!cv_cap ? cv_cap + 1 : cv_cap * 2));
            }
          } while (0);
          do {
            if (((v))) {
              ((size_t *)(((v))))[-2] = (0);
            }
          } while (0);
        } else {
          size_t *cv_p1 = &((size_t *)((v)))[-2];
          size_t *cv_p2 = realloc(cv_p1, (cv_sz));
          assert(cv_p2);
          ((v)) = (void *)(&cv_p2[2]);
          do {
            if (((v))) {
              ((size_t *)(((v))))[-1] = ((!cv_cap ? cv_cap + 1 : cv_cap * 2));
            }
          } while (0);
        }
      } while (0);
    }
    v[((v) ? ((size_t *)(v))[-2] : (size_t)0)] = (10);
    do {
      if ((v)) {
        ((size_t *)((v)))[-2] = (((v) ? ((size_t *)(v))[-2] : (size_t)0) + 1);
      }
    } while (0);
  } while (0);
  do {
    size_t cv_cap = ((v) ? ((size_t *)(v))[-1] : (size_t)0);
    if (cv_cap <= ((v) ? ((size_t *)(v))[-2] : (size_t)0)) {
      do {
        const size_t cv_sz =
            (!cv_cap ? cv_cap + 1 : cv_cap * 2) * sizeof(*((v))) +
            (sizeof(size_t) * 2);
        if (!((v))) {
          size_t *cv_p = malloc(cv_sz);
          assert(cv_p);
          ((v)) = (void *)(&cv_p[2]);
          do {
            if (((v))) {
              ((size_t *)(((v))))[-1] = ((!cv_cap ? cv_cap + 1 : cv_cap * 2));
            }
          } while (0);
          do {
            if (((v))) {
              ((size_t *)(((v))))[-2] = (0);
            }
          } while (0);
        } else {
          size_t *cv_p1 = &((size_t *)((v)))[-2];
          size_t *cv_p2 = realloc(cv_p1, (cv_sz));
          assert(cv_p2);
          ((v)) = (void *)(&cv_p2[2]);
          do {
            if (((v))) {
              ((size_t *)(((v))))[-1] = ((!cv_cap ? cv_cap + 1 : cv_cap * 2));
            }
          } while (0);
        }
      } while (0);
    }
    v[((v) ? ((size_t *)(v))[-2] : (size_t)0)] = (20);
    do {
      if ((v)) {
        ((size_t *)((v)))[-2] = (((v) ? ((size_t *)(v))[-2] : (size_t)0) + 1);
      }
    } while (0);
  } while (0);
  do {
    size_t cv_cap = ((v) ? ((size_t *)(v))[-1] : (size_t)0);
    if (cv_cap <= ((v) ? ((size_t *)(v))[-2] : (size_t)0)) {
      do {
        const size_t cv_sz =
            (!cv_cap ? cv_cap + 1 : cv_cap * 2) * sizeof(*((v))) +
            (sizeof(size_t) * 2);
        if (!((v))) {
          size_t *cv_p = malloc(cv_sz);
          assert(cv_p);
          ((v)) = (void *)(&cv_p[2]);
          do {
            if (((v))) {
              ((size_t *)(((v))))[-1] = ((!cv_cap ? cv_cap + 1 : cv_cap * 2));
            }
          } while (0);
          do {
            if (((v))) {
              ((size_t *)(((v))))[-2] = (0);
            }
          } while (0);
        } else {
          size_t *cv_p1 = &((size_t *)((v)))[-2];
          size_t *cv_p2 = realloc(cv_p1, (cv_sz));
          assert(cv_p2);
          ((v)) = (void *)(&cv_p2[2]);
          do {
            if (((v))) {
              ((size_t *)(((v))))[-1] = ((!cv_cap ? cv_cap + 1 : cv_cap * 2));
            }
          } while (0);
        }
      } while (0);
    }
    v[((v) ? ((size_t *)(v))[-2] : (size_t)0)] = (30);
    do {
      if ((v)) {
        ((size_t *)((v)))[-2] = (((v) ? ((size_t *)(v))[-2] : (size_t)0) + 1);
      }
    } while (0);
  } while (0);
  do {
    do {
      if ((v)) {
        ((size_t *)((v)))[-2] = (((v) ? ((size_t *)(v))[-2] : (size_t)0) - 1);
      }
    } while (0);
  } while (0);
  printf("pointer : %p\n", (void *)v);
  printf("capacity: %lu\n", ((v) ? ((size_t *)(v))[-1] : (size_t)0));
  printf("size    : %lu\n", ((v) ? ((size_t *)(v))[-2] : (size_t)0));
  if (v) {
    int *it;
    int i = 0;
    for (it = (v);
         it != ((v) ? &((v)[((v) ? ((size_t *)(v))[-2] : (size_t)0)]) : NULL);
         ++it) {
      printf("v[%d] = %d\n", i, *it);
      ++i;
    }
  }
  if (v) {
    size_t i;
    for (i = 0; i < ((v) ? ((size_t *)(v))[-2] : (size_t)0); ++i) {
      printf("v[%lu] = %d\n", i, v[i]);
    }
  }
  do {
    if (v) {
      size_t *p1 = &((size_t *)(v))[-2];
      free(p1);
    }
  } while (0);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1190 <main+0x40>
mov    -0x18(%rbp),%rax
mov    -0x8(%rax),%rax
mov    %rax,-0xb8(%rbp)
jmp    119e <main+0x4e>
xor    %eax,%eax
mov    %rax,-0xb8(%rbp)
jmp    119e <main+0x4e>
mov    -0xb8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0xc0(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     11d3 <main+0x83>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0xc8(%rbp)
jmp    11e1 <main+0x91>
xor    %eax,%eax
mov    %rax,-0xc8(%rbp)
jmp    11e1 <main+0x91>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rcx
cmp    %rcx,%rax
ja     136c <main+0x21c>
jmp    11fd <main+0xad>
cmpq   $0x0,-0x20(%rbp)
jne    121c <main+0xcc>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd0(%rbp)
jmp    122b <main+0xdb>
mov    -0x20(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
shl    $0x2,%rax
add    $0x10,%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    12de <main+0x18e>
mov    -0x28(%rbp),%rdi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
call   1050 <assert@plt>
mov    -0x30(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     12b3 <main+0x163>
cmpq   $0x0,-0x20(%rbp)
jne    1295 <main+0x145>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd8(%rbp)
jmp    12a4 <main+0x154>
mov    -0x20(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,-0x8(%rax)
jmp    12b8 <main+0x168>
jmp    12bd <main+0x16d>
cmpq   $0x0,-0x18(%rbp)
je     12d4 <main+0x184>
mov    -0x18(%rbp),%rax
movq   $0x0,-0x10(%rax)
jmp    12d9 <main+0x189>
jmp    1362 <main+0x212>
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1070 <realloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rdi
call   1050 <assert@plt>
mov    -0x40(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1358 <main+0x208>
cmpq   $0x0,-0x20(%rbp)
jne    133a <main+0x1ea>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xe0(%rbp)
jmp    1349 <main+0x1f9>
mov    -0x20(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,-0x8(%rax)
jmp    135d <main+0x20d>
jmp    1362 <main+0x212>
jmp    1367 <main+0x217>
jmp    136c <main+0x21c>
mov    -0x18(%rbp),%rax
mov    %rax,-0xe8(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1396 <main+0x246>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0xf0(%rbp)
jmp    13a4 <main+0x254>
xor    %eax,%eax
mov    %rax,-0xf0(%rbp)
jmp    13a4 <main+0x254>
mov    -0xe8(%rbp),%rax
mov    -0xf0(%rbp),%rcx
movl   $0xa,(%rax,%rcx,4)
cmpq   $0x0,-0x18(%rbp)
je     1404 <main+0x2b4>
cmpq   $0x0,-0x18(%rbp)
je     13e3 <main+0x293>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0xf8(%rbp)
jmp    13f1 <main+0x2a1>
xor    %eax,%eax
mov    %rax,-0xf8(%rbp)
jmp    13f1 <main+0x2a1>
mov    -0xf8(%rbp),%rcx
add    $0x1,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,-0x10(%rax)
jmp    1409 <main+0x2b9>
jmp    140e <main+0x2be>
jmp    1413 <main+0x2c3>
cmpq   $0x0,-0x18(%rbp)
je     1432 <main+0x2e2>
mov    -0x18(%rbp),%rax
mov    -0x8(%rax),%rax
mov    %rax,-0x100(%rbp)
jmp    1440 <main+0x2f0>
xor    %eax,%eax
mov    %rax,-0x100(%rbp)
jmp    1440 <main+0x2f0>
mov    -0x100(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x108(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1475 <main+0x325>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0x110(%rbp)
jmp    1483 <main+0x333>
xor    %eax,%eax
mov    %rax,-0x110(%rbp)
jmp    1483 <main+0x333>
mov    -0x108(%rbp),%rax
mov    -0x110(%rbp),%rcx
cmp    %rcx,%rax
ja     160e <main+0x4be>
jmp    149f <main+0x34f>
cmpq   $0x0,-0x48(%rbp)
jne    14be <main+0x36e>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x118(%rbp)
jmp    14cd <main+0x37d>
mov    -0x48(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x118(%rbp)
mov    -0x118(%rbp),%rax
shl    $0x2,%rax
add    $0x10,%rax
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1580 <main+0x430>
mov    -0x50(%rbp),%rdi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
call   1050 <assert@plt>
mov    -0x58(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1555 <main+0x405>
cmpq   $0x0,-0x48(%rbp)
jne    1537 <main+0x3e7>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x120(%rbp)
jmp    1546 <main+0x3f6>
mov    -0x48(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x120(%rbp)
mov    -0x120(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,-0x8(%rax)
jmp    155a <main+0x40a>
jmp    155f <main+0x40f>
cmpq   $0x0,-0x18(%rbp)
je     1576 <main+0x426>
mov    -0x18(%rbp),%rax
movq   $0x0,-0x10(%rax)
jmp    157b <main+0x42b>
jmp    1604 <main+0x4b4>
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rdi
mov    -0x50(%rbp),%rsi
call   1070 <realloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rdi
call   1050 <assert@plt>
mov    -0x68(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     15fa <main+0x4aa>
cmpq   $0x0,-0x48(%rbp)
jne    15dc <main+0x48c>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x128(%rbp)
jmp    15eb <main+0x49b>
mov    -0x48(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,-0x8(%rax)
jmp    15ff <main+0x4af>
jmp    1604 <main+0x4b4>
jmp    1609 <main+0x4b9>
jmp    160e <main+0x4be>
mov    -0x18(%rbp),%rax
mov    %rax,-0x130(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1638 <main+0x4e8>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0x138(%rbp)
jmp    1646 <main+0x4f6>
xor    %eax,%eax
mov    %rax,-0x138(%rbp)
jmp    1646 <main+0x4f6>
mov    -0x130(%rbp),%rax
mov    -0x138(%rbp),%rcx
movl   $0x14,(%rax,%rcx,4)
cmpq   $0x0,-0x18(%rbp)
je     16a6 <main+0x556>
cmpq   $0x0,-0x18(%rbp)
je     1685 <main+0x535>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0x140(%rbp)
jmp    1693 <main+0x543>
xor    %eax,%eax
mov    %rax,-0x140(%rbp)
jmp    1693 <main+0x543>
mov    -0x140(%rbp),%rcx
add    $0x1,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,-0x10(%rax)
jmp    16ab <main+0x55b>
jmp    16b0 <main+0x560>
jmp    16b5 <main+0x565>
cmpq   $0x0,-0x18(%rbp)
je     16d4 <main+0x584>
mov    -0x18(%rbp),%rax
mov    -0x8(%rax),%rax
mov    %rax,-0x148(%rbp)
jmp    16e2 <main+0x592>
xor    %eax,%eax
mov    %rax,-0x148(%rbp)
jmp    16e2 <main+0x592>
mov    -0x148(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x150(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1717 <main+0x5c7>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0x158(%rbp)
jmp    1725 <main+0x5d5>
xor    %eax,%eax
mov    %rax,-0x158(%rbp)
jmp    1725 <main+0x5d5>
mov    -0x150(%rbp),%rax
mov    -0x158(%rbp),%rcx
cmp    %rcx,%rax
ja     18bf <main+0x76f>
jmp    1741 <main+0x5f1>
cmpq   $0x0,-0x70(%rbp)
jne    1760 <main+0x610>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    176f <main+0x61f>
mov    -0x70(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x160(%rbp)
mov    -0x160(%rbp),%rax
shl    $0x2,%rax
add    $0x10,%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1822 <main+0x6d2>
mov    -0x78(%rbp),%rdi
call   1060 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rdi
call   1050 <assert@plt>
mov    -0x80(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     17f7 <main+0x6a7>
cmpq   $0x0,-0x70(%rbp)
jne    17d9 <main+0x689>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x168(%rbp)
jmp    17e8 <main+0x698>
mov    -0x70(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x168(%rbp)
mov    -0x168(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,-0x8(%rax)
jmp    17fc <main+0x6ac>
jmp    1801 <main+0x6b1>
cmpq   $0x0,-0x18(%rbp)
je     1818 <main+0x6c8>
mov    -0x18(%rbp),%rax
movq   $0x0,-0x10(%rax)
jmp    181d <main+0x6cd>
jmp    18b5 <main+0x765>
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rdi
mov    -0x78(%rbp),%rsi
call   1070 <realloc@plt>
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rdi
call   1050 <assert@plt>
mov    -0x90(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     18ab <main+0x75b>
cmpq   $0x0,-0x70(%rbp)
jne    188d <main+0x73d>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    189c <main+0x74c>
mov    -0x70(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x170(%rbp)
mov    -0x170(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,-0x8(%rax)
jmp    18b0 <main+0x760>
jmp    18b5 <main+0x765>
jmp    18ba <main+0x76a>
jmp    18bf <main+0x76f>
mov    -0x18(%rbp),%rax
mov    %rax,-0x178(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     18e9 <main+0x799>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0x180(%rbp)
jmp    18f7 <main+0x7a7>
xor    %eax,%eax
mov    %rax,-0x180(%rbp)
jmp    18f7 <main+0x7a7>
mov    -0x178(%rbp),%rax
mov    -0x180(%rbp),%rcx
movl   $0x1e,(%rax,%rcx,4)
cmpq   $0x0,-0x18(%rbp)
je     1957 <main+0x807>
cmpq   $0x0,-0x18(%rbp)
je     1936 <main+0x7e6>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0x188(%rbp)
jmp    1944 <main+0x7f4>
xor    %eax,%eax
mov    %rax,-0x188(%rbp)
jmp    1944 <main+0x7f4>
mov    -0x188(%rbp),%rcx
add    $0x1,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,-0x10(%rax)
jmp    195c <main+0x80c>
jmp    1961 <main+0x811>
jmp    1966 <main+0x816>
jmp    196b <main+0x81b>
cmpq   $0x0,-0x18(%rbp)
je     19b6 <main+0x866>
cmpq   $0x0,-0x18(%rbp)
je     1995 <main+0x845>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0x190(%rbp)
jmp    19a3 <main+0x853>
xor    %eax,%eax
mov    %rax,-0x190(%rbp)
jmp    19a3 <main+0x853>
mov    -0x190(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,-0x10(%rax)
jmp    19bb <main+0x86b>
jmp    19c0 <main+0x870>
mov    -0x18(%rbp),%rsi
lea    0x635(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmpq   $0x0,-0x18(%rbp)
je     19f1 <main+0x8a1>
mov    -0x18(%rbp),%rax
mov    -0x8(%rax),%rax
mov    %rax,-0x198(%rbp)
jmp    19ff <main+0x8af>
xor    %eax,%eax
mov    %rax,-0x198(%rbp)
jmp    19ff <main+0x8af>
mov    -0x198(%rbp),%rsi
lea    0x601(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmpq   $0x0,-0x18(%rbp)
je     1a33 <main+0x8e3>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0x1a0(%rbp)
jmp    1a41 <main+0x8f1>
xor    %eax,%eax
mov    %rax,-0x1a0(%rbp)
jmp    1a41 <main+0x8f1>
mov    -0x1a0(%rbp),%rsi
lea    0x5ce(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmpq   $0x0,-0x18(%rbp)
je     1b56 <main+0xa06>
movl   $0x0,-0x9c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1ae8 <main+0x998>
mov    -0x18(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1ab9 <main+0x969>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0x1b8(%rbp)
jmp    1ac7 <main+0x977>
xor    %eax,%eax
mov    %rax,-0x1b8(%rbp)
jmp    1ac7 <main+0x977>
mov    -0x1b0(%rbp),%rax
mov    -0x1b8(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x1c0(%rbp)
jmp    1af6 <main+0x9a6>
xor    %eax,%eax
mov    %rax,-0x1c0(%rbp)
jmp    1af6 <main+0x9a6>
mov    -0x1a8(%rbp),%rax
mov    -0x1c0(%rbp),%rcx
cmp    %rcx,%rax
je     1b51 <main+0xa01>
movslq -0x9c(%rbp),%rsi
mov    -0x98(%rbp),%rax
mov    (%rax),%edx
lea    0x508(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x98(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x98(%rbp)
jmp    1a76 <main+0x926>
jmp    1b56 <main+0xa06>
cmpq   $0x0,-0x18(%rbp)
je     1bfd <main+0xaad>
movq   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1b99 <main+0xa49>
mov    -0x18(%rbp),%rax
mov    -0x10(%rax),%rax
mov    %rax,-0x1d0(%rbp)
jmp    1ba7 <main+0xa57>
xor    %eax,%eax
mov    %rax,-0x1d0(%rbp)
jmp    1ba7 <main+0xa57>
mov    -0x1c8(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
cmp    %rcx,%rax
jae    1bf8 <main+0xaa8>
mov    -0xa8(%rbp),%rsi
mov    -0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0x45e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xa8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa8(%rbp)
jmp    1b6c <main+0xa1c>
jmp    1bfd <main+0xaad>
jmp    1c02 <main+0xab2>
cmpq   $0x0,-0x18(%rbp)
je     1c28 <main+0xad8>
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
jmp    1c2d <main+0xadd>
xor    %eax,%eax
add    $0x1d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    $0x14,%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
call   1050 <assert@plt>
movl   $0xa,0x10(%rbx)
movaps 0xe84(%rip),%xmm0
movups %xmm0,(%rbx)
mov    $0x18,%esi
mov    %rbx,%rdi
call   1070 <realloc@plt>
mov    %rax,%r12
mov    %rax,%rdi
call   1050 <assert@plt>
movq   $0x2,0x8(%r12)
mov    (%r12),%rax
movl   $0x14,0x10(%r12,%rax,4)
add    $0x1,%rax
mov    %rax,(%r12)
cmp    $0x2,%rax
jb     11dc <main+0x8c>
mov    $0x20,%esi
mov    %r12,%rdi
call   1070 <realloc@plt>
mov    %rax,%r12
mov    %rax,%rdi
call   1050 <assert@plt>
movq   $0x4,0x8(%r12)
add    $0x10,%r12
lea    -0x10(%r12),%r14
mov    -0x10(%r12),%rax
movl   $0x1e,(%r12,%rax,4)
mov    %rax,-0x10(%r12)
lea    0xe12(%rip),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    -0x8(%r12),%rsi
lea    0xe0a(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    -0x10(%r12),%rsi
lea    0xe06(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
cmpq   $0x0,-0x10(%r12)
je     12ac <main+0x15c>
lea    0xdff(%rip),%r15
xor    %r13d,%r13d
mov    %r12,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx),%edx
mov    %r15,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%r13
add    $0x4,%rbx
mov    -0x10(%r12),%rax
lea    (%r12,%rax,4),%rcx
cmp    %rcx,%rbx
jne    1250 <main+0x100>
test   %rax,%rax
je     12ac <main+0x15c>
lea    0xdc7(%rip),%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r12,%rbx,4),%edx
mov    %r15,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    -0x10(%r12),%rbx
jb     1290 <main+0x140>
mov    %r14,%rdi
call   1030 <free@plt>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [14 x i8] c"pointer : %p\0A\00"
@.str.1 = [15 x i8] c"capacity: %lu\0A\00"
@.str.2 = [15 x i8] c"size : %lu\0A\00"
@.str.3 = [12 x i8] c"v[%d] = %d\0A\00"
@.str.4 = [13 x i8] c"v[%lu] = %d\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32*
%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 i64*
%20 = alloca i64*
%21 = alloca i64*
%22 = alloca i32*
%23 = alloca i32
%24 = alloca i64
%25 = alloca i64*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32* null, i32** %6
%26 = load i32, i32* %4
%27 = load i8**, i8*** %5
br label %28
28: ; preds = %2
%29 = load i32*, i32** %6
%30 = icmp ne i32* %29, null
br i1 %30, label %31, label %36
31: ; preds = %28
%32 = load i32*, i32** %6
%33 = bitcast i32* %32 to i64*
%34 = getelementptr inbounds i64, i64* %33, i64 -1
%35 = load i64, i64* %34
br label %37
36: ; preds = %28
br label %37
37: ; preds = %36, %31
%38 = phi i64 [ %35, %31 ], [ 0, %36 ]
store i64 %38, i64* %7
%39 = load i64, i64* %7
%40 = load i32*, i32** %6
%41 = icmp ne i32* %40, null
br i1 %41, label %42, label %47
42: ; preds = %37
%43 = load i32*, i32** %6
%44 = bitcast i32* %43 to i64*
%45 = getelementptr inbounds i64, i64* %44, i64 -2
%46 = load i64, i64* %45
br label %48
47: ; preds = %37
br label %48
48: ; preds = %47, %42
%49 = phi i64 [ %46, %42 ], [ 0, %47 ]
%50 = icmp ule i64 %39, %49
br i1 %50, label %51, label %138
51: ; preds = %48
br label %52
52: ; preds = %51
%53 = load i64, i64* %7
%54 = icmp ne i64 %53, 0
br i1 %54, label %58, label %55
55: ; preds = %52
%56 = load i64, i64* %7
%57 = add i64 %56, 1
br label %61
58: ; preds = %52
%59 = load i64, i64* %7
%60 = mul i64 %59, 2
br label %61
61: ; preds = %58, %55
%62 = phi i64 [ %57, %55 ], [ %60, %58 ]
%63 = mul i64 %62, 4
%64 = add i64 %63, 16
store i64 %64, i64* %8
%65 = load i32*, i32** %6
%66 = icmp ne i32* %65, null
br i1 %66, label %104, label %67
67: ; preds = %61
%68 = load i64, i64* %8
%69 = call i64* @malloc(i64 %68)
store i64* %69, i64** %9
%70 = load i64*, i64** %9
%71 = call i32 @assert(i64* %70)
%72 = load i64*, i64** %9
%73 = getelementptr inbounds i64, i64* %72, i64 2
%74 = bitcast i64* %73 to i8*
%75 = bitcast i8* %74 to i32*
store i32* %75, i32** %6
br label %76
76: ; preds = %67
%77 = load i32*, i32** %6
%78 = icmp ne i32* %77, null
br i1 %78, label %79, label %93
79: ; preds = %76
%80 = load i64, i64* %7
%81 = icmp ne i64 %80, 0
br i1 %81, label %85, label %82
82: ; preds = %79
%83 = load i64, i64* %7
%84 = add i64 %83, 1
br label %88
85: ; preds = %79
%86 = load i64, i64* %7
%87 = mul i64 %86, 2
br label %88
88: ; preds = %85, %82
%89 = phi i64 [ %84, %82 ], [ %87, %85 ]
%90 = load i32*, i32** %6
%91 = bitcast i32* %90 to i64*
%92 = getelementptr inbounds i64, i64* %91, i64 -1
store i64 %89, i64* %92
br label %93
93: ; preds = %88, %76
br label %94
94: ; preds = %93
br label %95
95: ; preds = %94
%96 = load i32*, i32** %6
%97 = icmp ne i32* %96, null
br i1 %97, label %98, label %102
98: ; preds = %95
%99 = load i32*, i32** %6
%100 = bitcast i32* %99 to i64*
%101 = getelementptr inbounds i64, i64* %100, i64 -2
store i64 0, i64* %101
br label %102
102: ; preds = %98, %95
br label %103
103: ; preds = %102
br label %136
104: ; preds = %61
%105 = load i32*, i32** %6
%106 = bitcast i32* %105 to i64*
%107 = getelementptr inbounds i64, i64* %106, i64 -2
store i64* %107, i64** %10
%108 = load i64*, i64** %10
%109 = load i64, i64* %8
%110 = call i64* @realloc(i64* %108, i64 %109)
store i64* %110, i64** %11
%111 = load i64*, i64** %11
%112 = call i32 @assert(i64* %111)
%113 = load i64*, i64** %11
%114 = getelementptr inbounds i64, i64* %113, i64 2
%115 = bitcast i64* %114 to i8*
%116 = bitcast i8* %115 to i32*
store i32* %116, i32** %6
br label %117
117: ; preds = %104
%118 = load i32*, i32** %6
%119 = icmp ne i32* %118, null
br i1 %119, label %120, label %134
120: ; preds = %117
%121 = load i64, i64* %7
%122 = icmp ne i64 %121, 0
br i1 %122, label %126, label %123
123: ; preds = %120
%124 = load i64, i64* %7
%125 = add i64 %124, 1
br label %129
126: ; preds = %120
%127 = load i64, i64* %7
%128 = mul i64 %127, 2
br label %129
129: ; preds = %126, %123
%130 = phi i64 [ %125, %123 ], [ %128, %126 ]
%131 = load i32*, i32** %6
%132 = bitcast i32* %131 to i64*
%133 = getelementptr inbounds i64, i64* %132, i64 -1
store i64 %130, i64* %133
br label %134
134: ; preds = %129, %117
br label %135
135: ; preds = %134
br label %136
136: ; preds = %135, %103
br label %137
137: ; preds = %136
br label %138
138: ; preds = %137, %48
%139 = load i32*, i32** %6
%140 = load i32*, i32** %6
%141 = icmp ne i32* %140, null
br i1 %141, label %142, label %147
142: ; preds = %138
%143 = load i32*, i32** %6
%144 = bitcast i32* %143 to i64*
%145 = getelementptr inbounds i64, i64* %144, i64 -2
%146 = load i64, i64* %145
br label %148
147: ; preds = %138
br label %148
148: ; preds = %147, %142
%149 = phi i64 [ %146, %142 ], [ 0, %147 ]
%150 = getelementptr inbounds i32, i32* %139, i64 %149
store i32 10, i32* %150
br label %151
151: ; preds = %148
%152 = load i32*, i32** %6
%153 = icmp ne i32* %152, null
br i1 %153, label %154, label %169
154: ; preds = %151
%155 = load i32*, i32** %6
%156 = icmp ne i32* %155, null
br i1 %156, label %157, label %162
157: ; preds = %154
%158 = load i32*, i32** %6
%159 = bitcast i32* %158 to i64*
%160 = getelementptr inbounds i64, i64* %159, i64 -2
%161 = load i64, i64* %160
br label %163
162: ; preds = %154
br label %163
163: ; preds = %162, %157
%164 = phi i64 [ %161, %157 ], [ 0, %162 ]
%165 = add i64 %164, 1
%166 = load i32*, i32** %6
%167 = bitcast i32* %166 to i64*
%168 = getelementptr inbounds i64, i64* %167, i64 -2
store i64 %165, i64* %168
br label %169
169: ; preds = %163, %151
br label %170
170: ; preds = %169
br label %171
171: ; preds = %170
br label %172
172: ; preds = %171
%173 = load i32*, i32** %6
%174 = icmp ne i32* %173, null
br i1 %174, label %175, label %180
175: ; preds = %172
%176 = load i32*, i32** %6
%177 = bitcast i32* %176 to i64*
%178 = getelementptr inbounds i64, i64* %177, i64 -1
%179 = load i64, i64* %178
br label %181
180: ; preds = %172
br label %181
181: ; preds = %180, %175
%182 = phi i64 [ %179, %175 ], [ 0, %180 ]
store i64 %182, i64* %12
%183 = load i64, i64* %12
%184 = load i32*, i32** %6
%185 = icmp ne i32* %184, null
br i1 %185, label %186, label %191
186: ; preds = %181
%187 = load i32*, i32** %6
%188 = bitcast i32* %187 to i64*
%189 = getelementptr inbounds i64, i64* %188, i64 -2
%190 = load i64, i64* %189
br label %192
191: ; preds = %181
br label %192
192: ; preds = %191, %186
%193 = phi i64 [ %190, %186 ], [ 0, %191 ]
%194 = icmp ule i64 %183, %193
br i1 %194, label %195, label %282
195: ; preds = %192
br label %196
196: ; preds = %195
%197 = load i64, i64* %12
%198 = icmp ne i64 %197, 0
br i1 %198, label %202, label %199
199: ; preds = %196
%200 = load i64, i64* %12
%201 = add i64 %200, 1
br label %205
202: ; preds = %196
%203 = load i64, i64* %12
%204 = mul i64 %203, 2
br label %205
205: ; preds = %202, %199
%206 = phi i64 [ %201, %199 ], [ %204, %202 ]
%207 = mul i64 %206, 4
%208 = add i64 %207, 16
store i64 %208, i64* %13
%209 = load i32*, i32** %6
%210 = icmp ne i32* %209, null
br i1 %210, label %248, label %211
211: ; preds = %205
%212 = load i64, i64* %13
%213 = call i64* @malloc(i64 %212)
store i64* %213, i64** %14
%214 = load i64*, i64** %14
%215 = call i32 @assert(i64* %214)
%216 = load i64*, i64** %14
%217 = getelementptr inbounds i64, i64* %216, i64 2
%218 = bitcast i64* %217 to i8*
%219 = bitcast i8* %218 to i32*
store i32* %219, i32** %6
br label %220
220: ; preds = %211
%221 = load i32*, i32** %6
%222 = icmp ne i32* %221, null
br i1 %222, label %223, label %237
223: ; preds = %220
%224 = load i64, i64* %12
%225 = icmp ne i64 %224, 0
br i1 %225, label %229, label %226
226: ; preds = %223
%227 = load i64, i64* %12
%228 = add i64 %227, 1
br label %232
229: ; preds = %223
%230 = load i64, i64* %12
%231 = mul i64 %230, 2
br label %232
232: ; preds = %229, %226
%233 = phi i64 [ %228, %226 ], [ %231, %229 ]
%234 = load i32*, i32** %6
%235 = bitcast i32* %234 to i64*
%236 = getelementptr inbounds i64, i64* %235, i64 -1
store i64 %233, i64* %236
br label %237
237: ; preds = %232, %220
br label %238
238: ; preds = %237
br label %239
239: ; preds = %238
%240 = load i32*, i32** %6
%241 = icmp ne i32* %240, null
br i1 %241, label %242, label %246
242: ; preds = %239
%243 = load i32*, i32** %6
%244 = bitcast i32* %243 to i64*
%245 = getelementptr inbounds i64, i64* %244, i64 -2
store i64 0, i64* %245
br label %246
246: ; preds = %242, %239
br label %247
247: ; preds = %246
br label %280
248: ; preds = %205
%249 = load i32*, i32** %6
%250 = bitcast i32* %249 to i64*
%251 = getelementptr inbounds i64, i64* %250, i64 -2
store i64* %251, i64** %15
%252 = load i64*, i64** %15
%253 = load i64, i64* %13
%254 = call i64* @realloc(i64* %252, i64 %253)
store i64* %254, i64** %16
%255 = load i64*, i64** %16
%256 = call i32 @assert(i64* %255)
%257 = load i64*, i64** %16
%258 = getelementptr inbounds i64, i64* %257, i64 2
%259 = bitcast i64* %258 to i8*
%260 = bitcast i8* %259 to i32*
store i32* %260, i32** %6
br label %261
261: ; preds = %248
%262 = load i32*, i32** %6
%263 = icmp ne i32* %262, null
br i1 %263, label %264, label %278
264: ; preds = %261
%265 = load i64, i64* %12
%266 = icmp ne i64 %265, 0
br i1 %266, label %270, label %267
267: ; preds = %264
%268 = load i64, i64* %12
%269 = add i64 %268, 1
br label %273
270: ; preds = %264
%271 = load i64, i64* %12
%272 = mul i64 %271, 2
br label %273
273: ; preds = %270, %267
%274 = phi i64 [ %269, %267 ], [ %272, %270 ]
%275 = load i32*, i32** %6
%276 = bitcast i32* %275 to i64*
%277 = getelementptr inbounds i64, i64* %276, i64 -1
store i64 %274, i64* %277
br label %278
278: ; preds = %273, %261
br label %279
279: ; preds = %278
br label %280
280: ; preds = %279, %247
br label %281
281: ; preds = %280
br label %282
282: ; preds = %281, %192
%283 = load i32*, i32** %6
%284 = load i32*, i32** %6
%285 = icmp ne i32* %284, null
br i1 %285, label %286, label %291
286: ; preds = %282
%287 = load i32*, i32** %6
%288 = bitcast i32* %287 to i64*
%289 = getelementptr inbounds i64, i64* %288, i64 -2
%290 = load i64, i64* %289
br label %292
291: ; preds = %282
br label %292
292: ; preds = %291, %286
%293 = phi i64 [ %290, %286 ], [ 0, %291 ]
%294 = getelementptr inbounds i32, i32* %283, i64 %293
store i32 20, i32* %294
br label %295
295: ; preds = %292
%296 = load i32*, i32** %6
%297 = icmp ne i32* %296, null
br i1 %297, label %298, label %313
298: ; preds = %295
%299 = load i32*, i32** %6
%300 = icmp ne i32* %299, null
br i1 %300, label %301, label %306
301: ; preds = %298
%302 = load i32*, i32** %6
%303 = bitcast i32* %302 to i64*
%304 = getelementptr inbounds i64, i64* %303, i64 -2
%305 = load i64, i64* %304
br label %307
306: ; preds = %298
br label %307
307: ; preds = %306, %301
%308 = phi i64 [ %305, %301 ], [ 0, %306 ]
%309 = add i64 %308, 1
%310 = load i32*, i32** %6
%311 = bitcast i32* %310 to i64*
%312 = getelementptr inbounds i64, i64* %311, i64 -2
store i64 %309, i64* %312
br label %313
313: ; preds = %307, %295
br label %314
314: ; preds = %313
br label %315
315: ; preds = %314
br label %316
316: ; preds = %315
%317 = load i32*, i32** %6
%318 = icmp ne i32* %317, null
br i1 %318, label %319, label %324
319: ; preds = %316
%320 = load i32*, i32** %6
%321 = bitcast i32* %320 to i64*
%322 = getelementptr inbounds i64, i64* %321, i64 -1
%323 = load i64, i64* %322
br label %325
324: ; preds = %316
br label %325
325: ; preds = %324, %319
%326 = phi i64 [ %323, %319 ], [ 0, %324 ]
store i64 %326, i64* %17
%327 = load i64, i64* %17
%328 = load i32*, i32** %6
%329 = icmp ne i32* %328, null
br i1 %329, label %330, label %335
330: ; preds = %325
%331 = load i32*, i32** %6
%332 = bitcast i32* %331 to i64*
%333 = getelementptr inbounds i64, i64* %332, i64 -2
%334 = load i64, i64* %333
br label %336
335: ; preds = %325
br label %336
336: ; preds = %335, %330
%337 = phi i64 [ %334, %330 ], [ 0, %335 ]
%338 = icmp ule i64 %327, %337
br i1 %338, label %339, label %426
339: ; preds = %336
br label %340
340: ; preds = %339
%341 = load i64, i64* %17
%342 = icmp ne i64 %341, 0
br i1 %342, label %346, label %343
343: ; preds = %340
%344 = load i64, i64* %17
%345 = add i64 %344, 1
br label %349
346: ; preds = %340
%347 = load i64, i64* %17
%348 = mul i64 %347, 2
br label %349
349: ; preds = %346, %343
%350 = phi i64 [ %345, %343 ], [ %348, %346 ]
%351 = mul i64 %350, 4
%352 = add i64 %351, 16
store i64 %352, i64* %18
%353 = load i32*, i32** %6
%354 = icmp ne i32* %353, null
br i1 %354, label %392, label %355
355: ; preds = %349
%356 = load i64, i64* %18
%357 = call i64* @malloc(i64 %356)
store i64* %357, i64** %19
%358 = load i64*, i64** %19
%359 = call i32 @assert(i64* %358)
%360 = load i64*, i64** %19
%361 = getelementptr inbounds i64, i64* %360, i64 2
%362 = bitcast i64* %361 to i8*
%363 = bitcast i8* %362 to i32*
store i32* %363, i32** %6
br label %364
364: ; preds = %355
%365 = load i32*, i32** %6
%366 = icmp ne i32* %365, null
br i1 %366, label %367, label %381
367: ; preds = %364
%368 = load i64, i64* %17
%369 = icmp ne i64 %368, 0
br i1 %369, label %373, label %370
370: ; preds = %367
%371 = load i64, i64* %17
%372 = add i64 %371, 1
br label %376
373: ; preds = %367
%374 = load i64, i64* %17
%375 = mul i64 %374, 2
br label %376
376: ; preds = %373, %370
%377 = phi i64 [ %372, %370 ], [ %375, %373 ]
%378 = load i32*, i32** %6
%379 = bitcast i32* %378 to i64*
%380 = getelementptr inbounds i64, i64* %379, i64 -1
store i64 %377, i64* %380
br label %381
381: ; preds = %376, %364
br label %382
382: ; preds = %381
br label %383
383: ; preds = %382
%384 = load i32*, i32** %6
%385 = icmp ne i32* %384, null
br i1 %385, label %386, label %390
386: ; preds = %383
%387 = load i32*, i32** %6
%388 = bitcast i32* %387 to i64*
%389 = getelementptr inbounds i64, i64* %388, i64 -2
store i64 0, i64* %389
br label %390
390: ; preds = %386, %383
br label %391
391: ; preds = %390
br label %424
392: ; preds = %349
%393 = load i32*, i32** %6
%394 = bitcast i32* %393 to i64*
%395 = getelementptr inbounds i64, i64* %394, i64 -2
store i64* %395, i64** %20
%396 = load i64*, i64** %20
%397 = load i64, i64* %18
%398 = call i64* @realloc(i64* %396, i64 %397)
store i64* %398, i64** %21
%399 = load i64*, i64** %21
%400 = call i32 @assert(i64* %399)
%401 = load i64*, i64** %21
%402 = getelementptr inbounds i64, i64* %401, i64 2
%403 = bitcast i64* %402 to i8*
%404 = bitcast i8* %403 to i32*
store i32* %404, i32** %6
br label %405
405: ; preds = %392
%406 = load i32*, i32** %6
%407 = icmp ne i32* %406, null
br i1 %407, label %408, label %422
408: ; preds = %405
%409 = load i64, i64* %17
%410 = icmp ne i64 %409, 0
br i1 %410, label %414, label %411
411: ; preds = %408
%412 = load i64, i64* %17
%413 = add i64 %412, 1
br label %417
414: ; preds = %408
%415 = load i64, i64* %17
%416 = mul i64 %415, 2
br label %417
417: ; preds = %414, %411
%418 = phi i64 [ %413, %411 ], [ %416, %414 ]
%419 = load i32*, i32** %6
%420 = bitcast i32* %419 to i64*
%421 = getelementptr inbounds i64, i64* %420, i64 -1
store i64 %418, i64* %421
br label %422
422: ; preds = %417, %405
br label %423
423: ; preds = %422
br label %424
424: ; preds = %423, %391
br label %425
425: ; preds = %424
br label %426
426: ; preds = %425, %336
%427 = load i32*, i32** %6
%428 = load i32*, i32** %6
%429 = icmp ne i32* %428, null
br i1 %429, label %430, label %435
430: ; preds = %426
%431 = load i32*, i32** %6
%432 = bitcast i32* %431 to i64*
%433 = getelementptr inbounds i64, i64* %432, i64 -2
%434 = load i64, i64* %433
br label %436
435: ; preds = %426
br label %436
436: ; preds = %435, %430
%437 = phi i64 [ %434, %430 ], [ 0, %435 ]
%438 = getelementptr inbounds i32, i32* %427, i64 %437
store i32 30, i32* %438
br label %439
439: ; preds = %436
%440 = load i32*, i32** %6
%441 = icmp ne i32* %440, null
br i1 %441, label %442, label %457
442: ; preds = %439
%443 = load i32*, i32** %6
%444 = icmp ne i32* %443, null
br i1 %444, label %445, label %450
445: ; preds = %442
%446 = load i32*, i32** %6
%447 = bitcast i32* %446 to i64*
%448 = getelementptr inbounds i64, i64* %447, i64 -2
%449 = load i64, i64* %448
br label %451
450: ; preds = %442
br label %451
451: ; preds = %450, %445
%452 = phi i64 [ %449, %445 ], [ 0, %450 ]
%453 = add i64 %452, 1
%454 = load i32*, i32** %6
%455 = bitcast i32* %454 to i64*
%456 = getelementptr inbounds i64, i64* %455, i64 -2
store i64 %453, i64* %456
br label %457
457: ; preds = %451, %439
br label %458
458: ; preds = %457
br label %459
459: ; preds = %458
br label %460
460: ; preds = %459
br label %461
461: ; preds = %460
%462 = load i32*, i32** %6
%463 = icmp ne i32* %462, null
br i1 %463, label %464, label %479
464: ; preds = %461
%465 = load i32*, i32** %6
%466 = icmp ne i32* %465, null
br i1 %466, label %467, label %472
467: ; preds = %464
%468 = load i32*, i32** %6
%469 = bitcast i32* %468 to i64*
%470 = getelementptr inbounds i64, i64* %469, i64 -2
%471 = load i64, i64* %470
br label %473
472: ; preds = %464
br label %473
473: ; preds = %472, %467
%474 = phi i64 [ %471, %467 ], [ 0, %472 ]
%475 = sub i64 %474, 1
%476 = load i32*, i32** %6
%477 = bitcast i32* %476 to i64*
%478 = getelementptr inbounds i64, i64* %477, i64 -2
store i64 %475, i64* %478
br label %479
479: ; preds = %473, %461
br label %480
480: ; preds = %479
br label %481
481: ; preds = %480
%482 = load i32*, i32** %6
%483 = bitcast i32* %482 to i8*
%484 = ptrtoint i8* %483 to i64
%485 = call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i64 %484)
%486 = load i32*, i32** %6
%487 = icmp ne i32* %486, null
br i1 %487, label %488, label %493
488: ; preds = %481
%489 = load i32*, i32** %6
%490 = bitcast i32* %489 to i64*
%491 = getelementptr inbounds i64, i64* %490, i64 -1
%492 = load i64, i64* %491
br label %494
493: ; preds = %481
br label %494
494: ; preds = %493, %488
%495 = phi i64 [ %492, %488 ], [ 0, %493 ]
%496 = call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0), i64 %495)
%497 = load i32*, i32** %6
%498 = icmp ne i32* %497, null
br i1 %498, label %499, label %504
499: ; preds = %494
%500 = load i32*, i32** %6
%501 = bitcast i32* %500 to i64*
%502 = getelementptr inbounds i64, i64* %501, i64 -2
%503 = load i64, i64* %502
br label %505
504: ; preds = %494
br label %505
505: ; preds = %504, %499
%506 = phi i64 [ %503, %499 ], [ 0, %504 ]
%507 = call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i64 %506)
%508 = load i32*, i32** %6
%509 = icmp ne i32* %508, null
br i1 %509, label %510, label %545
510: ; preds = %505
store i32 0, i32* %23
%511 = load i32*, i32** %6
store i32* %511, i32** %22
br label %512
512: ; preds = %541, %510
%513 = load i32*, i32** %22
%514 = load i32*, i32** %6
%515 = icmp ne i32* %514, null
br i1 %515, label %516, label %529
516: ; preds = %512
%517 = load i32*, i32** %6
%518 = load i32*, i32** %6
%519 = icmp ne i32* %518, null
br i1 %519, label %520, label %525
520: ; preds = %516
%521 = load i32*, i32** %6
%522 = bitcast i32* %521 to i64*
%523 = getelementptr inbounds i64, i64* %522, i64 -2
%524 = load i64, i64* %523
br label %526
525: ; preds = %516
br label %526
526: ; preds = %525, %520
%527 = phi i64 [ %524, %520 ], [ 0, %525 ]
%528 = getelementptr inbounds i32, i32* %517, i64 %527
br label %530
529: ; preds = %512
br label %530
530: ; preds = %529, %526
%531 = phi i32* [ %528, %526 ], [ null, %529 ]
%532 = icmp ne i32* %513, %531
br i1 %532, label %533, label %544
533: ; preds = %530
%534 = load i32, i32* %23
%535 = sext i32 %534 to i64
%536 = load i32*, i32** %22
%537 = load i32, i32* %536
%538 = call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0), i64 %535, i32 %537)
%539 = load i32, i32* %23
%540 = add nsw i32 %539, 1
store i32 %540, i32* %23
br label %541
541: ; preds = %533
%542 = load i32*, i32** %22
%543 = getelementptr inbounds i32, i32* %542, i32 1
store i32* %543, i32** %22
br label %512
544: ; preds = %530
br label %545
545: ; preds = %544, %505
%546 = load i32*, i32** %6
%547 = icmp ne i32* %546, null
br i1 %547, label %548, label %573
548: ; preds = %545
store i64 0, i64* %24
br label %549
549: ; preds = %569, %548
%550 = load i64, i64* %24
%551 = load i32*, i32** %6
%552 = icmp ne i32* %551, null
br i1 %552, label %553, label %558
553: ; preds = %549
%554 = load i32*, i32** %6
%555 = bitcast i32* %554 to i64*
%556 = getelementptr inbounds i64, i64* %555, i64 -2
%557 = load i64, i64* %556
br label %559
558: ; preds = %549
br label %559
559: ; preds = %558, %553
%560 = phi i64 [ %557, %553 ], [ 0, %558 ]
%561 = icmp ult i64 %550, %560
br i1 %561, label %562, label %572
562: ; preds = %559
%563 = load i64, i64* %24
%564 = load i32*, i32** %6
%565 = load i64, i64* %24
%566 = getelementptr inbounds i32, i32* %564, i64 %565
%567 = load i32, i32* %566
%568 = call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i64 0, i64 0), i64 %563, i32 %567)
br label %569
569: ; preds = %562
%570 = load i64, i64* %24
%571 = add i64 %570, 1
store i64 %571, i64* %24
br label %549
572: ; preds = %559
br label %573
573: ; preds = %572, %545
br label %574
574: ; preds = %573
%575 = load i32*, i32** %6
%576 = icmp ne i32* %575, null
br i1 %576, label %577, label %583
577: ; preds = %574
%578 = load i32*, i32** %6
%579 = bitcast i32* %578 to i64*
%580 = getelementptr inbounds i64, i64* %579, i64 -2
store i64* %580, i64** %25
%581 = load i64*, i64** %25
%582 = call i32 @free(i64* %581)
br label %583
583: ; preds = %577, %574
br label %584
584: ; preds = %583
ret i32 0
}

LLVM IR (-O2):
@.str = [14 x i8] c"pointer : %p\0A\00"
@.str.1 = [15 x i8] c"capacity: %lu\0A\00"
@.str.2 = [15 x i8] c"size : %lu\0A\00"
@.str.3 = [12 x i8] c"v[%d] = %d\0A\00"
@.str.4 = [13 x i8] c"v[%lu] = %d\0A\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = tail call i64* @malloc(i64 20)
%4 = tail call i32 @assert(i64* %3)
%5 = getelementptr inbounds i64, i64* %3, i64 2
%6 = bitcast i64* %5 to i32*
store i32 10, i32* %6
%7 = bitcast i64* %3 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %7
%8 = tail call i64* @realloc(i64* %3, i64 24)
%9 = tail call i32 @assert(i64* %8)
%10 = getelementptr inbounds i64, i64* %8, i64 2
%11 = bitcast i64* %10 to i32*
%12 = getelementptr inbounds i64, i64* %8, i64 1
store i64 2, i64* %12
%13 = load i64, i64* %8
%14 = getelementptr inbounds i32, i32* %11, i64 %13
store i32 20, i32* %14
%15 = add i64 %13, 1
store i64 %15, i64* %8
%16 = icmp ult i64 %15, 2
br i1 %16, label %23, label %17
17: ; preds = %2
%18 = tail call i64* @realloc(i64* %8, i64 32)
%19 = tail call i32 @assert(i64* %18)
%20 = getelementptr inbounds i64, i64* %18, i64 2
%21 = bitcast i64* %20 to i32*
%22 = getelementptr inbounds i64, i64* %18, i64 1
store i64 4, i64* %22
br label %23
23: ; preds = %2, %17
%24 = phi i32* [ %21, %17 ], [ %11, %2 ]
%25 = getelementptr inbounds i32, i32* %24, i64 -4
%26 = bitcast i32* %25 to i64*
%27 = load i64, i64* %26
%28 = getelementptr inbounds i32, i32* %24, i64 %27
store i32 30, i32* %28
store i64 %27, i64* %26
%29 = ptrtoint i32* %24 to i64
%30 = tail call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i64 %29)
%31 = getelementptr inbounds i32, i32* %24, i64 -2
%32 = bitcast i32* %31 to i64*
%33 = load i64, i64* %32
%34 = tail call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0), i64 %33)
%35 = load i64, i64* %26
%36 = tail call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i64 %35)
%37 = load i64, i64* %26
%38 = icmp eq i64 %37, 0
br i1 %38, label %59, label %41
39: ; preds = %41
%40 = icmp eq i64 %48, 0
br i1 %40, label %59, label %51
41: ; preds = %23, %41
%42 = phi i64 [ %46, %41 ], [ 0, %23 ]
%43 = phi i32* [ %47, %41 ], [ %24, %23 ]
%44 = load i32, i32* %43
%45 = tail call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0), i64 %42, i32 %44)
%46 = add nuw i64 %42, 1
%47 = getelementptr inbounds i32, i32* %43, i64 1
%48 = load i64, i64* %26
%49 = getelementptr inbounds i32, i32* %24, i64 %48
%50 = icmp eq i32* %47, %49
br i1 %50, label %39, label %41
51: ; preds = %39, %51
%52 = phi i64 [ %56, %51 ], [ 0, %39 ]
%53 = getelementptr inbounds i32, i32* %24, i64 %52
%54 = load i32, i32* %53
%55 = tail call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i64 0, i64 0), i64 %52, i32 %54)
%56 = add nuw i64 %52, 1
%57 = load i64, i64* %26
%58 = icmp ult i64 %56, %57
br i1 %58, label %51, label %59
59: ; preds = %51, %23, %39
%60 = tail call i32 @free(i64* %26)
ret i32 0
}