LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/./iovec_cursor.h
// Function: iovec_cursor_copy
static size_t MAYBEUNUSED
iovec_cursor_copy(struct iovec_cursor *dest, struct iovec_cursor *src,
                  size_t len) {
  while (len && dest->i < dest->count && src->i < src->count) {
    size_t bytes = src->iov[src->i].iov_len - src->j;
    if (bytes > len) bytes = len;

    dest->iov[dest->i].iov_base = src->iov[src->i].iov_base + src->j;
    dest->iov[dest->i].iov_len = bytes;

    len -= bytes;
    src->j += bytes;
    if (src->j == src->iov[src->i].iov_len) {
      src->j = 0;
      src->i++;
    }
    dest->i++;
  }

  return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0x2cd3
movl 0x1c(%rdi), %eax
cmpl 0x18(%rdi), %eax
jae 0x2cd3
movl 0x1c(%rsi), %ecx
cmpl 0x18(%rsi), %ecx
jae 0x2cd3
movq %rcx, %r9
shlq $0x4, %r9
movq 0x10(%rsi), %r10
movq 0x20(%rsi), %r11
movq 0x8(%r10,%r9), %r8
subq %r11, %r8
cmpq %rdx, %r8
cmovaeq %rdx, %r8
leaq (%r8,%r11), %rbx
addq (%r10,%r9), %r11
movq 0x10(%rdi), %r14
movq %rax, %r15
shlq $0x4, %r15
movq %r11, (%r14,%r15)
movq %r8, 0x8(%r14,%r15)
movq %rbx, 0x20(%rsi)
cmpq 0x8(%r10,%r9), %rbx
jne 0x2cc9
andq $0x0, 0x20(%rsi)
incl %ecx
movl %ecx, 0x1c(%rsi)
movl 0x1c(%rdi), %eax
subq %r8, %rdx
incl %eax
movl %eax, 0x1c(%rdi)
jmp 0x2c62
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/libobstcp.c
// Function: obstcp_accum_commit
ssize_t EXPORTED
obstcp_accum_commit(struct obstcp_accum *ac, ssize_t bytes) {
  struct obstcp_accum_buffer *ab = NULL;
  uint8_t c, next;
  ssize_t used = 0;

  if (bytes < 0) {
    errno = EINVAL;
    return -1;
  }

  for (c = ac->data_head; bytes && c != 0xff; c = next) {
    ab = &ac->buffers[c];

    if (ab->prefix_used < ab->prefix_len) {
      size_t a = ab->prefix_len - ab->prefix_used;
      if (a > bytes) a = bytes;
      ab->prefix_used += a;
      bytes -= a;
    }

    size_t a = ab->payload_len - ab->payload_used;
    if (a > bytes) a = bytes;
    ab->payload_used += a;
    bytes -= a;
    used += a;

    next = ab->next;

    if (ab->payload_len == ab->payload_used &&
        ab->prefix_len == ab->prefix_used) {

      ac->data_head = ab->next;
      if (ac->data_head == 0xff) ac->data_tail = 0xff;

      ab->next = ac->free_head;
      ac->free_head = c;
    }
  }

  // The user has claimed to have written more bytes than we've ever given
  // them.
  if (bytes) {
    errno = EINVAL;
    return -1;
  }

  return used;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
js 0x2e15
movb 0x1bb(%rdi), %bl
leaq 0xa(%rdi), %rcx
xorl %eax, %eax
testq %rsi, %rsi
je 0x2e10
movl %ebx, %edx
cmpb $-0x1, %bl
je 0x2e10
movzbl %dl, %r8d
imulq $0x48, %r8, %r10
leaq (%rcx,%r10), %r8
movb 0x5(%rcx,%r10), %r9b
movzbl 0x4(%rcx,%r10), %r10d
cmpb %r10b, %r9b
jae 0x2da8
movzbl %r9b, %r11d
movq %r10, %rbx
subq %r11, %rbx
cmpq %rsi, %rbx
cmovaeq %rsi, %rbx
addl %ebx, %r9d
movb %r9b, 0x5(%r8)
subq %rbx, %rsi
movzwl (%r8), %r14d
movzwl 0x2(%r8), %ebx
movq %r14, %r11
subq %rbx, %r11
cmpq %rsi, %r11
cmovaeq %rsi, %r11
leal (%r11,%rbx), %ebp
movw %bp, 0x2(%r8)
subq %r11, %rsi
addq %rax, %r11
movb 0x6(%r8), %bl
movq %r11, %rax
cmpw %bp, %r14w
jne 0x2d5d
movq %r11, %rax
cmpb %r9b, %r10b
jne 0x2d5d
movb %bl, 0x1bb(%rdi)
cmpb $-0x1, %bl
jne 0x2df8
movb $-0x1, 0x1bc(%rdi)
movb 0x1ba(%rdi), %al
movb %al, 0x6(%r8)
movb %dl, 0x1ba(%rdi)
movq %r11, %rax
jmp 0x2d5d
testq %rsi, %rsi
je 0x2e23
callq 0x1050
movl $0x16, (%rax)
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/./varbuf.h
// Function: varbuf_free
static void MAYBEUNUSED
varbuf_free(struct varbuf *vb) {
  struct chunk *c, *next;

  for (c = vb->head; c; c = next) {
    next = c->next;
    free(c);
  }
}

// Assembly:
pushq %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2e81
movq 0x20(%rdi), %rbx
callq 0x1030
movq %rbx, %rdi
jmp 0x2e6e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/./varbuf.h
// Function: varbuf_copy_in
static int MAYBEUNUSED
varbuf_copy_in(struct varbuf *vb, const uint8_t *buffer, size_t len) {
  off_t j = 0;

  if (vb->tail) {
    size_t remaining = vb->tail->length - vb->tail->used;
    if (remaining > len)
      remaining = len;

    memcpy(vb->tail->data + vb->tail->used, buffer, remaining);
    vb->tail->used += remaining;
    j += remaining;
    len -= remaining;
  }

  if (len) {
    size_t alloc = len;
    if (alloc < VARBUF_CHUNK_SIZE)
      alloc = VARBUF_CHUNK_SIZE;

    struct chunk *const chunk = malloc(sizeof(struct chunk) + alloc);
    if (!chunk) {
      errno = ENOMEM;
      return -1;
    }

    chunk->length = alloc;
    chunk->used = len;
    chunk->read = 0;
    chunk->next = NULL;
    chunk->prev = vb->tail;
    if (vb->tail) {
      vb->tail->next = chunk;
      vb->tail = chunk;
    } else {
      vb->tail = vb->head = chunk;
    }

    memcpy(chunk->data, buffer + j, len);
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x31aa
movq (%rax), %r13
movq 0x8(%rax), %rcx
subq %rcx, %r13
cmpq %r14, %r13
cmovaeq %r14, %r13
leaq (%rax,%rcx), %rdi
addq $0x28, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x10b0
movq 0x8(%r12), %rbp
addq %r13, 0x8(%rbp)
subq %r13, %r14
jmp 0x31af
xorl %ebp, %ebp
xorl %r13d, %r13d
testq %r14, %r14
je 0x3221
cmpq $0x101, %r14            # imm = 0x101
movl $0x100, %ebx            # imm = 0x100
cmovaeq %r14, %rbx
leaq 0x28(%rbx), %rdi
callq 0x10c0
testq %rax, %rax
je 0x3213
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
andq $0x0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movq %rbp, 0x18(%rax)
leaq 0x20(%rbp), %rcx
testq %rbp, %rbp
cmoveq %r12, %rcx
movq %rax, (%rcx)
movq %rax, 0x8(%r12)
addq $0x28, %rax
addq %r13, %r15
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10b0
xorl %ebx, %ebx
jmp 0x3221
callq 0x1050
movl $0xc, (%rax)
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/libobstcp.c
// Function: read_wrapper
static ssize_t
read_wrapper(void *ctx, uint8_t *buffer, size_t len) {
  intptr_t fd = (intptr_t) ctx;
  ssize_t n;

  do {
    n = read(fd, buffer, len);
  } while (n == -1 && errno == EINTR);

  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1090
movq %rax, %r12
cmpq $-0x1, %rax
jne 0x327c
callq 0x1050
cmpl $0x4, (%rax)
je 0x325b
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/libobstcp.c
// Function: varint_put
static int
varint_put(uint8_t *out, unsigned length, unsigned *offset, unsigned v) {
  do {
    if (*offset >= length) return 0;
    if (v > 127) {
      out[*offset] = 0x80 | (v & 0x7f);
    } else {
      out[*offset] = v;
    }

    v >>= 7;
    (*offset)++;
  } while (v);

  return 1;
}

// Assembly:
movl (%rdx), %r8d
pushq $0x1
popq %rax
cmpl %esi, %r8d
jae 0x32c8
movl %ecx, %r9d
orb $-0x80, %r9b
cmpl $0x7f, %ecx
movzbl %r9b, %r9d
cmovbel %ecx, %r9d
movl %r8d, %r8d
movb %r9b, (%rdi,%r8)
movl %ecx, %r9d
shrl $0x7, %r9d
movl (%rdx), %r8d
incl %r8d
movl %r8d, (%rdx)
cmpl $0x7f, %ecx
movl %r9d, %ecx
ja 0x3291
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/libobstcp.c
// Function: varint_get
static int
varint_get(uint32_t *v, const uint8_t *banner, unsigned length, unsigned *j) {
  uint32_t accum = 0;
  unsigned bytes = 0;

  do {
    if (*j > length) return 0;
    accum <<= 7;
    accum += banner[*j] & 0x7f;
    bytes++;
  } while (bytes < 4 && banner[(*j)++] & 0x80);

  *v = accum;
  return 1;
}

// Assembly:
pushq %rbx
movl (%rcx), %r8d
xorl %eax, %eax
movl $0x3, %r9d
xorl %r10d, %r10d
cmpl %edx, %r8d
ja 0x330f
movl %r10d, %ebx
shll $0x7, %ebx
movl %r8d, %r11d
movzbl (%rsi,%r11), %r10d
andl $0x7f, %r10d
orl %ebx, %r10d
subl $0x1, %r9d
jb 0x3307
incl %r8d
movl %r8d, (%rcx)
cmpb $0x0, (%rsi,%r11)
js 0x32da
movl %r10d, (%rdi)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/./iovec_cursor.h
// Function: iovec_cursor_get_
static int MAYBEUNUSED
iovec_cursor_get_(void *arg, struct iovec *iov, size_t n) {
  struct iovec_cursor *c = arg;

  if (c->i == c->count)
    return 0;

  size_t todo = c->iov[c->i].iov_len - c->j;
  if (todo > n)
    todo = n;

  iov->iov_base = c->iov[c->i].iov_base + c->j;
  iov->iov_len = todo;

  c->j += todo;
  if (c->j == c->iov[c->i].iov_len) {
    c->j = 0;
    c->i++;
  }

  return 1;
}

// Assembly:
movl 0x1c(%rdi), %ecx
xorl %eax, %eax
cmpl 0x18(%rdi), %ecx
je 0x3373
movq %rcx, %r8
shlq $0x4, %r8
movq 0x10(%rdi), %r9
movq 0x20(%rdi), %rax
movq 0x8(%r9,%r8), %r10
subq %rax, %r10
cmpq %rdx, %r10
cmovaeq %rdx, %r10
movq (%r9,%r8), %rdx
addq %rax, %rdx
movq %rdx, (%rsi)
movq %r10, 0x8(%rsi)
addq %rax, %r10
movq %r10, 0x20(%rdi)
pushq $0x1
popq %rax
cmpq 0x8(%r9,%r8), %r10
jne 0x3373
andq $0x0, 0x20(%rdi)
incl %ecx
movl %ecx, 0x1c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/./iovec_cursor.h
// Function: iovec_cursor_fold
static int MAYBEUNUSED
iovec_cursor_fold(void *arg, int (*f) (void *, uint8_t *, size_t len), void *ctx) {
  struct iovec_cursor *c = arg;
  int r;
  unsigned i;

  for (i = c->i; i < c->count; ++i) {
    if (i == c->i) {
      r = f(ctx, c->iov[i].iov_base + c->j, c->iov[i].iov_len - c->j);
    } else {
      r = f(ctx, c->iov[i].iov_base, c->iov[i].iov_len);
    }

    if (r)
      return r;
  }

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x1c(%rdi), %r12d
movq %r12, %r13
shlq $0x4, %r13
orq $0x8, %r13
movl 0x18(%r15), %eax
cmpq %rax, %r12
jae 0x33d7
movl 0x1c(%r15), %ecx
movq 0x10(%r15), %rax
movq -0x8(%rax,%r13), %rsi
cmpq %rcx, %r12
jne 0x33c0
movq 0x20(%r15), %rcx
addq %rcx, %rsi
movq (%rax,%r13), %rdx
subq %rcx, %rdx
jmp 0x33c4
movq (%rax,%r13), %rdx
movq %rbx, %rdi
callq *%r14
incq %r12
addq $0x10, %r13
testl %eax, %eax
je 0x3395
jmp 0x33d9
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/libobstcp.c
// Function: xor
static void
xor(uint8_t *dst, const uint8_t *src, const uint8_t *xorbytes, unsigned l) {
  const unsigned words = l >> 2;
  const unsigned bytes = l & 3;
  uint32_t *dst32 = (uint32_t *) dst;
  const uint32_t *src32 = (uint32_t *) src;
  const uint32_t *xorbytes32 = (uint32_t *) xorbytes;
  unsigned i;

  for (i = 0; i < words; ++i) {
    dst32[i] = src32[i] ^ xorbytes32[i];
  }

  for (i = 0; i < bytes; ++i) {
    dst[words * 4 + i] = src[words * 4 + i] ^ xorbytes[words * 4 + i];
  }
}

// Assembly:
movl %ecx, %eax
shrl $0x2, %eax
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x3401
movl (%rdx,%r8,4), %r9d
xorl (%rsi,%r8,4), %r9d
movl %r9d, (%rdi,%r8,4)
incq %r8
jmp 0x33eb
movl %ecx, %eax
andl $0x3, %eax
andl $-0x4, %ecx
addq %rcx, %rsi
addq %rcx, %rdx
addq %rcx, %rdi
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x342a
movb (%rdx,%rcx), %r8b
xorb (%rsi,%rcx), %r8b
movb %r8b, (%rdi,%rcx)
incq %rcx
jmp 0x3414
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/./varbuf.h
// Function: varbuf_cursor_get
static int MAYBEUNUSED
varbuf_cursor_get(void *arg, struct iovec *iov, size_t n) {
  struct varbuf_cursor *c = arg;

  if (c->chunk) {
    size_t todo = c->chunk->used - c->chunk->read;
    if (todo > n)
      todo = n;
    iov->iov_base = c->chunk->data + c->chunk->read;
    iov->iov_len = todo;

    c->chunk->read += todo;
    if (c->chunk->read == c->chunk->used)
      c->chunk = c->chunk->next;

    return 1;
  }

  if (c->used > c->read) {
    size_t todo = c->used - c->read;
    if (todo > n)
      todo = n;
    iov->iov_base = c->extra + c->read;
    iov->iov_len = todo;

    c->read += todo;

    return 1;
  }

  return 0;
}

// Assembly:
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x3482
movq 0x8(%rcx), %r8
movq 0x10(%rcx), %rax
movq %r8, %r9
subq %rax, %r9
cmpq %rdx, %r9
cmovaeq %rdx, %r9
leaq (%rcx,%rax), %rdx
addq $0x28, %rdx
movq %rdx, (%rsi)
movq %r9, 0x8(%rsi)
addq %rax, %r9
movq %r9, 0x10(%rcx)
pushq $0x1
popq %rax
cmpq %r8, %r9
jne 0x34b0
movq 0x20(%rcx), %rcx
movq %rcx, 0x10(%rdi)
retq
movq 0x18(%rdi), %rcx
movq 0x28(%rdi), %r8
xorl %eax, %eax
subq %rcx, %r8
jbe 0x34b0
cmpq %rdx, %r8
cmovbq %r8, %rdx
movq 0x20(%rdi), %rax
addq %rcx, %rax
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
addq %rcx, %rdx
movq %rdx, 0x18(%rdi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/./varbuf.h
// Function: varbuf_cursor_fold
static int MAYBEUNUSED
varbuf_cursor_fold(void *arg, int (*f) (void *, uint8_t *, size_t), void *ctx) {
  struct varbuf_cursor *c = arg;
  int r;

  const struct chunk *chunk = c->chunk;
  while (chunk) {
    r = f(ctx, (uint8_t *) chunk->data + c->chunk->read, chunk->used - c->chunk->read);
    if (r)
      return r;
    chunk = chunk->next;
  }

  if (c->used - c->read) {
    r = f(ctx, c->extra, c->used - c->read);
  } else {
    r = 0;
  }

  return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq 0x10(%rdi), %r15
movq %r15, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x34fa
movq (%r15), %rax
movq 0x10(%rax), %rax
leaq (%r12,%rax), %rsi
addq $0x28, %rsi
movq 0x8(%r12), %rdx
subq %rax, %rdx
movq %rbx, %rdi
callq *%r13
addq $0x20, %r12
testl %eax, %eax
je 0x34ca
jmp 0x3506
movq 0x28(%r14), %rdx
xorl %eax, %eax
subq 0x18(%r14), %rdx
jne 0x3510
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x20(%r14), %rsi
movq %rbx, %rdi
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/sha256.c
// Function: sha256_update
void
sha256_update(struct sha256_ctx *md, const uint8_t *in, unsigned inlen) {
  unsigned n;
  unsigned block_size = sizeof(md->buf);

  if (md->curlen > block_size) return;

  while (inlen > 0) {
    if (md->curlen == 0 && inlen >= block_size) {
      sha256_transform(md->state, (uint8_t *)in);
      md->length += block_size * 8;
      in             += block_size;
      inlen          -= block_size;
    } else {
      n = MIN(inlen, (block_size - md->curlen));
      memcpy(md->buf + md->curlen, in, (size_t)n);
      md->curlen += n;
      in             += n;
      inlen          -= n;
      if (md->curlen == block_size) {
        sha256_transform(md->state, md->buf);
        md->length += block_size * 8;
        md->curlen = 0;
      }
    }
  }
}

// Assembly:
cmpl $0x40, 0x28(%rdi)
ja 0x3a6c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2c(%rdi), %r12
leaq 0x8(%rdi), %r13
testl %ebx, %ebx
je 0x3a5e
movl 0x28(%r15), %edi
testq %rdi, %rdi
setne %al
cmpl $0x40, %ebx
setb %cl
orb %al, %cl
jne 0x3a17
movq %r13, %rdi
movq %r14, %rsi
callq 0x3a6d
addq $0x200, (%r15)          # imm = 0x200
addq $0x40, %r14
addl $-0x40, %ebx
jmp 0x39e4
pushq $0x40
popq %rax
movl %eax, %ebp
subl %edi, %ebp
cmpl %ebp, %ebx
cmovbl %ebx, %ebp
addq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x10b0
movl %ebp, %eax
addl 0x28(%r15), %eax
subl %ebp, %ebx
movl %eax, 0x28(%r15)
addq %rbp, %r14
cmpl $0x40, %eax
jne 0x39e4
movq %r13, %rdi
movq %r12, %rsi
callq 0x3a6d
addq $0x200, (%r15)          # imm = 0x200
andl $0x0, 0x28(%r15)
jmp 0x39e4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/sha256.c
// Function: sha256_final
void
sha256_final(struct sha256_ctx *md, uint8_t *out) {
  unsigned i;

  if (md->curlen >= sizeof(md->buf)) return;

  /* increase the length of the message */
  md->length += md->curlen * 8;

  /* append the '1' bit */
  md->buf[md->curlen++] = (uint8_t)0x80;

  /* if the length is currently above 56 bytes we append zeros
   * then compress.  Then we can fall back to padding zeros and length
   * encoding like normal.
   */
  if (md->curlen > 56) {
    while (md->curlen < 64) {
      md->buf[md->curlen++] = (uint8_t)0;
    }
    sha256_transform(md->state, md->buf);
    md->curlen = 0;
  }

  /* pad upto 56 bytes of zeroes */
  while (md->curlen < 56) {
    md->buf[md->curlen++] = (uint8_t)0;
  }

  /* store length */
  put64_msb(md->length, md->buf + 56);
  sha256_transform(md->state, md->buf);

  /* copy output */
  for (i = 0; i < 8; i += 2) {
    put32_msb(md->state[i], out + (4 * i));
    put32_msb(md->state[i + 1], out + (4 * (i + 1)));
  }
}

// Assembly:
movl 0x28(%rdi), %eax
cmpq $0x3f, %rax
ja 0x54e3
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%rax,8), %rcx
addq %rcx, (%rdi)
leaq 0x2c(%rdi), %r15
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%rdi)
movb $-0x80, 0x2c(%rdi,%rax)
cmpl $0x38, %eax
jb 0x547e
cmpq $0x3f, %rax
je 0x546b
leal 0x2(%rax), %ecx
movl %ecx, 0x28(%r14)
movb $0x0, 0x2d(%r14,%rax)
incq %rax
jmp 0x5453
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x3a6d
andl $0x0, 0x28(%r14)
xorl %ecx, %ecx
movl %ecx, %eax
cmpq $0x37, %rax
ja 0x5499
leaq 0x1(%rax), %rcx
movl %ecx, 0x28(%r14)
movb $0x0, 0x2c(%r14,%rax)
movq %rcx, %rax
jmp 0x5480
movq (%r14), %rax
movq %rax, %rcx
shrq $0x20, %rcx
bswapl %eax
bswapl %ecx
movl %ecx, 0x64(%r14)
movl %eax, 0x68(%r14)
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x3a6d
xorl %eax, %eax
cmpq $0x7, %rax
ja 0x54de
movl 0x8(%r14,%rax,4), %ecx
bswapl %ecx
movl %ecx, (%rbx,%rax,4)
movl 0xc(%r14,%rax,4), %ecx
bswapl %ecx
movl %ecx, 0x4(%rbx,%rax,4)
addq $0x2, %rax
jmp 0x54bd
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/base32.c
// Function: base32_decode
int
base32_decode(uint8_t *output, const char *in, unsigned inlen) {
  unsigned i = 0, j = 0;
  unsigned v = 0, bits = 0;

  while (j < inlen) {
    if (in[j] & 0x80)
      goto PROTO;
    const uint8_t b = kValues[(int) in[j++]];
    if (b > 31)
      goto PROTO;

    v |= ((unsigned) b) << bits;
    bits += 5;

    if (bits >= 8) {
      output[i++] = v;
      bits -= 8;
      v >>= 8;
    }
  }

  return 1;

 PROTO:
  errno = EPROTO;
  return 0;
}

// Assembly:
pushq %rbx
movl %edx, %edx
xorl %r8d, %r8d
pushq $0x1
popq %rax
leaq 0x1d25(%rip), %r9       # 0x7220
xorl %r10d, %r10d
xorl %r11d, %r11d
xorl %ecx, %ecx
cmpq %r8, %rdx
je 0x5550
movsbq (%rsi,%r8), %rbx
testq %rbx, %rbx
js 0x5543
movzbl (%rbx,%r9), %ebx
cmpl $0x1f, %ebx
ja 0x5543
incq %r8
shll %cl, %ebx
orl %ebx, %r11d
leal 0x5(%rcx), %ebx
cmpl $0x3, %ecx
movl %ebx, %ecx
jb 0x5503
movl %r10d, %ecx
incl %r10d
movb %r11b, (%rdi,%rcx)
addl $-0x8, %ebx
shrl $0x8, %r11d
movl %ebx, %ecx
jmp 0x5503
callq 0x1050
movl $0x47, (%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/agl[P]obstcp/base32.c
// Function: base32_encode
void
base32_encode(char *output, const uint8_t *in, unsigned inlen) {
  unsigned i = 0, j = 0;
  unsigned v = 0, bits = 0;
  static const char kChars[] = "0123456789bcdfghjklmnpqrstuvwxyz";

  while (j < inlen) {
    v |= ((unsigned) in[j++]) << bits;
    bits += 8;

    while (bits >= 5) {
      output[i++] = kChars[v & 31];
      bits -= 5;
      v >>= 5;
    }
  }

  if (bits)
    output[i++] = kChars[v];
}

// Assembly:
pushq %rbx
movl %edx, %r8d
xorl %r10d, %r10d
leaq 0x1d31(%rip), %rax      # 0x72a0
xorl %edx, %edx
xorl %r9d, %r9d
xorl %ecx, %ecx
cmpq %r8, %r10
je 0x55af
movzbl (%rsi,%r10), %r11d
shll %cl, %r11d
orl %r11d, %r9d
orl $0x8, %ecx
cmpl $0x5, %ecx
jb 0x55aa
movl %r9d, %r11d
andl $0x1f, %r11d
movb (%r11,%rax), %r11b
movl %edx, %ebx
incl %edx
movb %r11b, (%rdi,%rbx)
addl $-0x5, %ecx
shrl $0x5, %r9d
jmp 0x5589
incq %r10
jmp 0x5576
testl %ecx, %ecx
je 0x55be
movl %r9d, %ecx
movb (%rcx,%rax), %al
movl %edx, %ecx
movb %al, (%rdi,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/9-File/simple_ls.c
// Function: main
int main(int argc, char **argv)
{
	DIR *dir;
	char *input = ".";
	struct dirent *entry;

	if(argc > 1)
		input = argv[1];

	if( (dir = opendir(input)) == NULL )
	{
		perror("opendir()");
		exit(1);
	}

	while( (entry = readdir(dir)) != NULL )
		printf("%ld\t\t%s\n",
			(long) entry->d_ino,
			entry->d_name);

	closedir(dir);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jl 0x119b
movq 0x8(%rsi), %rdi
jmp 0x11a2
leaq 0xe62(%rip), %rdi       # 0x2004
callq 0x1030
testq %rax, %rax
je 0x11eb
movq %rax, %rbx
leaq 0xe5a(%rip), %r14       # 0x2010
movq %rbx, %rdi
callq 0x1060
testq %rax, %rax
je 0x11d9
movq (%rax), %rsi
addq $0x13, %rax
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1040
jmp 0x11b6
movq %rbx, %rdi
callq 0x1050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xe14(%rip), %rdi       # 0x2006
callq 0x1070
pushq $0x1
popq %rdi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/lseek2.c
// Function: testcase_prepare
void testcase_prepare(unsigned long nr_tasks, unsigned long nr)
{
	char buf[BUFLEN];
	int fd = mkstemp(tmpfile);

	memset(buf, 0, sizeof(buf));
	assert(fd >= 0);
	assert(write(fd, buf, sizeof(buf)) == sizeof(buf));
	close(fd);
}

// Assembly:
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
leaq 0x2631(%rip), %rdi      # 0x5190
callq 0x21e0
movl %eax, %ebx
movq %rsp, %rdi
movl $0x1000, %edx           # imm = 0x1000
xorl %esi, %esi
callq 0x2140
testl %ebx, %ebx
js 0x2b9f
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebx, %edi
callq 0x20d0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2bb8
movl %ebx, %edi
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
jmp 0x2150
leaq 0x6d2(%rip), %rdi       # 0x3278
leaq 0x6d3(%rip), %rsi       # 0x3280
leaq 0x6db(%rip), %rcx       # 0x328f
pushq $0x13
jmp 0x2bcf
leaq 0x704(%rip), %rdi       # 0x32c3
leaq 0x6ba(%rip), %rsi       # 0x3280
leaq 0x6c2(%rip), %rcx       # 0x328f
pushq $0x14
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/lseek2.c
// Function: testcase
void testcase(unsigned long long *iterations)
{
	int fd = open(tmpfile, O_RDWR);

	assert(fd >= 0);

	while (1) {
		lseek(fd, 0, SEEK_SET);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x25ae(%rip), %rdi      # 0x5190
pushq $0x2
popq %rsi
xorl %eax, %eax
callq 0x2220
testl %eax, %eax
js 0x2c02
movl %eax, %ebp
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2120
incq (%rbx)
jmp 0x2bf2
leaq 0x66f(%rip), %rdi       # 0x3278
leaq 0x670(%rip), %rsi       # 0x3280
leaq 0x6d7(%rip), %rcx       # 0x32ee
pushq $0x1c
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel_test.c
// Function: test_unless
int test_unless() {
	size_t new_size = 0;
	const char document[] = 
		"xXx UNLESS @dne xXx\n"
		"<p>You should see this. 1/3</p>\n"
		"xXx ENDLESS xXx\n"
		"xXx UNLESS NOT @dne xXx\n"
		"<p>You should not see this. 1/3</p>\n"
		"xXx ENDLESS xXx\n"
		"xXx UNLESS @falsey xXx\n"
		"<p>You should see this. 2/3</p>\n"
		"xXx ENDLESS xXx\n"
		"xXx UNLESS NOT @falsey xXx\n"
		"<p>You should not see this. 2/3</p>\n"
		"xXx ENDLESS xXx\n"
		"xXx UNLESS @truthy xXx\n"
		"<p>You should not see this. 3/3</p>\n"
		"xXx ENDLESS xXx\n"
		"xXx UNLESS NOT @truthy xXx\n"
		"<p>You should see this. 3/3</p>\n"
		"xXx ENDLESS xXx\n";

	const char document_correct[] = "\n<p>You should see this. 1/3</p>\n"
		"\n<p>You should see this. 2/3</p>\n"
		"\n<p>You should see this. 3/3</p>\n";

	greshunkel_ctext *ctext = gshkl_init_context();
	gshkl_add_string(ctext, "truthy", "TRUE");
	gshkl_add_string(ctext, "falsey", "FALSE");
	char *rendered = gshkl_render(ctext, document, strlen(document), &new_size);
	gshkl_free_context(ctext);

	int ret = strcmp(rendered, document_correct);
	if (ret) {
		free(rendered);
		return 1;
	}

	free(rendered);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x3ea7(%rip), %rsi      # 0x51e0
leaq 0x10(%rsp), %r14
movl $0x1bd, %edx            # imm = 0x1BD
movq %r14, %rdi
callq 0x1190
xorl %eax, %eax
callq 0x1cb0
movq %rax, %r15
leaq 0x3caf(%rip), %rsi      # 0x500b
leaq 0x3caf(%rip), %rdx      # 0x5012
movq %rax, %rdi
callq 0x1e9f
leaq 0x3ca5(%rip), %rsi      # 0x5017
leaq 0x3ca5(%rip), %rdx      # 0x501e
movq %r15, %rdi
callq 0x1e9f
movl $0x1bc, %edx            # imm = 0x1BC
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x2398
movq %rax, %rbx
movq %r15, %rdi
callq 0x233e
leaq 0x3ffa(%rip), %rsi      # 0x53a0
movq %rbx, %rdi
callq 0x1170
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel_test.c
// Function: test_template_include
int test_template_include() {
	size_t new_size = 0;
	const char document[] = "xXx SCREAM _include.html xXx";
	const char document_correct[] = 
"<p>This is a test include file with it's own context and strings and stuff.</p>\n"
"\n"
"    <li>This is a test. a</li>\n"
"    <li>This is a test. b</li>\n"
"    <li>This is a test. c</li>\n"
"    <li>This is a test. 1</li>\n"
"    <li>This is a test. 2</li>\n"
"    <li>This is a test. 3</li>";

	greshunkel_ctext *ctext = gshkl_init_context();
	gshkl_add_string(ctext, "TEST", "This is a test.");
	greshunkel_var loop_test = gshkl_add_array(ctext, "LOOP_TEST");

	gshkl_add_string_to_loop(&loop_test, "a");
	gshkl_add_string_to_loop(&loop_test, "b");
	gshkl_add_string_to_loop(&loop_test, "c");

	gshkl_add_int_to_loop(&loop_test, 1);
	gshkl_add_int_to_loop(&loop_test, 2);
	gshkl_add_int_to_loop(&loop_test, 3);

	char *rendered = gshkl_render(ctext, document, strlen(document), &new_size);
	gshkl_free_context(ctext);

	int ret = strcmp(rendered, document_correct);
	if (ret) {
		free(rendered);
		return 1;
	}

	free(rendered);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x240, %rsp            # imm = 0x240
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movups 0x4030(%rip), %xmm0     # 0x541d
leaq 0x10(%rsp), %r14
movups %xmm0, 0xd(%r14)
movaps 0x4012(%rip), %xmm0     # 0x5410
movaps %xmm0, (%r14)
xorl %eax, %eax
callq 0x1cb0
movq %rax, %r15
leaq 0x3c89(%rip), %rsi      # 0x509c
leaq 0x3c0a(%rip), %rdx      # 0x5024
movq %rax, %rdi
callq 0x1e9f
leaq 0x3c6e(%rip), %rdx      # 0x5097
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2074
leaq 0x3bf4(%rip), %rsi      # 0x5034
movq %r12, %rdi
callq 0x228a
leaq 0x3c42(%rip), %rsi      # 0x5091
movq %r12, %rdi
callq 0x228a
leaq 0x4def(%rip), %rsi      # 0x624d
movq %r12, %rdi
callq 0x228a
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x2134
pushq $0x2
popq %rsi
movq %r12, %rdi
callq 0x2134
pushq $0x3
popq %rsi
movq %r12, %rdi
callq 0x2134
pushq $0x1c
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x2398
movq %rax, %rbx
movq %r15, %rdi
callq 0x233e
leaq 0x3f86(%rip), %rsi      # 0x5430
movq %rbx, %rdi
callq 0x1170
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel_test.c
// Function: test_filters
int test_filters() {
	size_t new_size = 0;
	const char document[] = "<li>XxX return_z xXx @ONE xXx XxX XxX return_z XxX</li>";

	greshunkel_ctext *ctext = gshkl_init_context();
	gshkl_add_int(ctext, "ONE", 1);
	gshkl_add_filter(ctext, "return_z", &return_z, NULL);

	char *rendered = gshkl_render(ctext, document, strlen(document), &new_size);
	gshkl_free_context(ctext);

	int ret = strcmp(rendered, "<li>z z</li>");
	if (ret) {
		free(rendered);
		return 1;
	}

	free(rendered);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movaps 0x4072(%rip), %xmm0     # 0x5560
leaq 0x10(%rsp), %r14
movaps %xmm0, 0x20(%r14)
movaps 0x4051(%rip), %xmm0     # 0x5550
movaps %xmm0, 0x10(%r14)
movaps 0x4035(%rip), %xmm0     # 0x5540
movaps %xmm0, (%r14)
movabsq $0x3e696c2f3c5878, %rax # imm = 0x3E696C2F3C5878
movq %rax, 0x30(%r14)
xorl %eax, %eax
callq 0x1cb0
movq %rax, %r15
leaq 0x3b08(%rip), %rsi      # 0x5036
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x1f88
leaq 0x3afa(%rip), %rsi      # 0x503a
leaq -0x23b(%rip), %rdx      # 0x130c
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x1e3d
pushq $0x37
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x2398
movq %rax, %rbx
movq %r15, %rdi
callq 0x233e
leaq 0x3acf(%rip), %rsi      # 0x5043
movq %rbx, %rdi
callq 0x1170
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel_test.c
// Function: test_variable_interpolation
int test_variable_interpolation() {
	const char templ_a[] = "xXx @image xXx";
	const char templ_b[] = "xXx @image_date xXx";

	greshunkel_ctext *ctext = gshkl_init_context();
	gshkl_add_string(ctext, "image", "test");
	gshkl_add_string(ctext, "image_date", "definitely_not_test");

	size_t a_siz = 0, b_siz = 0;
	char *a_rendered = gshkl_render(ctext, templ_a, strlen(templ_a), &a_siz);
	char *b_rendered = gshkl_render(ctext, templ_b, strlen(templ_b), &b_siz);
	gshkl_free_context(ctext);

	int ret = strcmp(a_rendered, b_rendered);
	if (!ret) {
		free(a_rendered);
		free(b_rendered);
		return 1;
	}

	free(a_rendered);
	free(b_rendered);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movabsq $0x78587820656761, %rax # imm = 0x78587820656761
leaq 0x10(%rsp), %r15
movq %rax, 0x7(%r15)
movabsq $0x616d694020785878, %rax # imm = 0x616D694020785878
movq %rax, (%r15)
movaps 0x48be(%rip), %xmm0     # 0x6120
leaq 0x20(%rsp), %rbx
movaps %xmm0, (%rbx)
movl $0x785878, 0x10(%rbx)   # imm = 0x785878
xorl %eax, %eax
callq 0x1cb0
movq %rax, %r14
leaq 0x384d(%rip), %rsi      # 0x50cf
leaq 0x3926(%rip), %rdx      # 0x51af
movq %rax, %rdi
callq 0x1e9f
leaq 0x383d(%rip), %rsi      # 0x50d5
leaq 0x3841(%rip), %rdx      # 0x50e0
movq %r14, %rdi
callq 0x1e9f
leaq 0x8(%rsp), %rcx
andq $0x0, (%rcx)
movq %rsp, %r12
andq $0x0, (%r12)
pushq $0xe
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2398
movq %rax, %r15
pushq $0x13
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rcx
callq 0x2398
movq %rax, %rbx
movq %r14, %rdi
callq 0x233e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1170
xorl %ebp, %ebp
testl %eax, %eax
sete %bpl
movq %r15, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel_test.c
// Function: test_subcontext_interpolation
int test_subcontext_interpolation() {
	size_t new_size = 0;
	const char document[] = 
		"xXx @image.name xXx\n"
		"xXx @image.id xXx";
	const char document_correct[] = "test_name\n1";

	greshunkel_ctext *ctext = gshkl_init_context();
	greshunkel_ctext *sub = gshkl_init_context();
	gshkl_add_string(sub, "name", "test_name");
	gshkl_add_int(sub, "id", 1);
	gshkl_add_sub_context(ctext, "image", sub);

	char *rendered = gshkl_render(ctext, document, strlen(document), &new_size);
	gshkl_free_context(ctext);

	int ret = strcmp(rendered, document_correct);
	if (ret) {
		free(rendered);
		return 1;
	}

	free(rendered);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movaps 0x481d(%rip), %xmm0     # 0x6150
leaq 0x10(%rsp), %r14
movaps %xmm0, 0x10(%r14)
movaps 0x47fc(%rip), %xmm0     # 0x6140
movaps %xmm0, (%r14)
movabsq $0x7858782064692e, %rax # imm = 0x7858782064692E
movq %rax, 0x1e(%r14)
xorl %eax, %eax
callq 0x1cb0
movq %rax, %r15
xorl %eax, %eax
callq 0x1cb0
movq %rax, %r12
leaq 0x3707(%rip), %rsi      # 0x5078
leaq 0x36fb(%rip), %rdx      # 0x5073
movq %rax, %rdi
callq 0x1e9f
leaq 0x3779(%rip), %rsi      # 0x5100
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x1f88
leaq 0x3736(%rip), %rsi      # 0x50cf
movq %r15, %rdi
movq %r12, %rdx
callq 0x1d46
pushq $0x25
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x2398
movq %rax, %rbx
movq %r15, %rdi
callq 0x233e
leaq 0x372d(%rip), %rsi      # 0x50f4
movq %rbx, %rdi
callq 0x1170
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel_test.c
// Function: test_loop_in_unless
int test_loop_in_unless() {
	size_t new_size = 0;
	const char document[] =
		"xXx UNLESS NOT @errors xXx\n"
		"    xXx LOOP error errors xXx\n"
		"        xXx @error xXx\n"
		"    xXx BBL xXx\n"
		"xXx ENDLESS xXx\n";
	const char document_correct[] = "\n        1\n    \n        2\n    \n        3\n    \n";

	greshunkel_ctext *ctext = gshkl_init_context();
	greshunkel_var loop = gshkl_add_array(ctext, "errors");
	gshkl_add_string_to_loop(&loop, "1");
	gshkl_add_string_to_loop(&loop, "2");
	gshkl_add_string_to_loop(&loop, "3");

	char *rendered = gshkl_render(ctext, document, strlen(document), &new_size);
	gshkl_free_context(ctext);

	int ret = strcmp(rendered, document_correct);
	if (ret) {
		free(rendered);
		return 1;
	}

	free(rendered);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x290, %rsp            # imm = 0x290
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x4763(%rip), %rsi      # 0x6170
pushq $0x71
popq %rcx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
rep  movsb (%rsi), %es:(%rdi)
xorl %eax, %eax
callq 0x1cb0
movq %rax, %r15
leaq 0x36d8(%rip), %rdx      # 0x5103
leaq 0x88(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x2074
leaq 0x36b9(%rip), %rsi      # 0x50fe
movq %r12, %rdi
callq 0x228a
leaq 0x36b6(%rip), %rsi      # 0x510a
movq %r12, %rdi
callq 0x228a
leaq 0x36a9(%rip), %rsi      # 0x510c
movq %r12, %rdi
callq 0x228a
pushq $0x70
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x2398
movq %rax, %rbx
movq %r15, %rdi
callq 0x233e
leaq 0x4762(%rip), %rsi      # 0x61f0
movq %rbx, %rdi
callq 0x1170
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x290, %rsp            # imm = 0x290
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel.c
// Function: gshkl_init_context
greshunkel_ctext *gshkl_init_context() {
	greshunkel_ctext *ctext = calloc(1, sizeof(struct greshunkel_ctext));
	assert(ctext != NULL);
	ctext->values = vector_new(sizeof(struct greshunkel_tuple), 32);
	assert(ctext->values != NULL);
	ctext->filter_functions = vector_new(sizeof(struct greshunkel_filter), 8);
	assert(ctext->filter_functions != NULL);
	return ctext;
}

// Assembly:
pushq %rbx
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x1160
testq %rax, %rax
je 0x1cf2
movq %rax, %rbx
pushq $0x20
popq %rsi
movl $0x230, %edi            # imm = 0x230
callq 0x438c
movq %rax, (%rbx)
testq %rax, %rax
je 0x1d0b
pushq $0x30
popq %rdi
pushq $0x8
popq %rsi
callq 0x438c
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1d24
movq %rbx, %rax
popq %rbx
retq
leaq 0x4537(%rip), %rdi      # 0x6230
leaq 0x453e(%rip), %rsi      # 0x623e
leaq 0x4548(%rip), %rcx      # 0x624f
pushq $0x33
jmp 0x1d3b
leaq 0x4564(%rip), %rdi      # 0x6276
leaq 0x4525(%rip), %rsi      # 0x623e
leaq 0x452f(%rip), %rcx      # 0x624f
pushq $0x35
jmp 0x1d3b
leaq 0x4561(%rip), %rdi      # 0x628c
leaq 0x450c(%rip), %rsi      # 0x623e
leaq 0x4516(%rip), %rcx      # 0x624f
pushq $0x37
popq %rdx
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel.c
// Function: gshkl_add_sub_context
int gshkl_add_sub_context(greshunkel_ctext *parent, const char name[const], const greshunkel_ctext *child) {
	assert(parent != NULL);
	assert(child != NULL);
	assert(name != NULL);

	/* Create a new tuple to hold type and name and shit. */
	greshunkel_tuple _stack_tuple = {
		.name = {0},
		.type = GSHKL_SUBCTEXT,
		.value = {
			.sub_ctext = child
		}
	};
	const size_t name_len = strnlen(name, WISDOM_OF_WORDS) < WISDOM_OF_WORDS ? strnlen(name, WISDOM_OF_WORDS) : WISDOM_OF_WORDS;
	strncpy(_stack_tuple.name, name, name_len);

	return _gshkl_add_var_to_context(parent, &_stack_tuple);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
testq %rdi, %rdi
je 0x1dd5
movq %rdx, %r15
testq %rdx, %rdx
je 0x1dee
movq %rsi, %r14
testq %rsi, %rsi
je 0x1e07
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movl $0x230, %edx            # imm = 0x230
movq %r12, %rdi
xorl %esi, %esi
callq 0x1120
movl $0x2, 0x20(%r12)
movq %r15, 0x28(%r12)
pushq $0x20
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1130
cmpq $0x20, %rax
cmovbq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1e24
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x44d0(%rip), %rdi      # 0x62ac
leaq 0x445b(%rip), %rsi      # 0x623e
leaq 0x44d1(%rip), %rcx      # 0x62bb
pushq $0x51
jmp 0x1e1e
leaq 0x4521(%rip), %rdi      # 0x6316
leaq 0x4442(%rip), %rsi      # 0x623e
leaq 0x44b8(%rip), %rcx      # 0x62bb
pushq $0x52
jmp 0x1e1e
leaq 0x4945(%rip), %rdi      # 0x6753
leaq 0x4429(%rip), %rsi      # 0x623e
leaq 0x449f(%rip), %rcx      # 0x62bb
pushq $0x53
popq %rdx
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel.c
// Function: gshkl_add_filter
int gshkl_add_filter(greshunkel_ctext *ctext,
		const char name[const],
		char *(*filter_func)(const char *argument),
		void (*clean_up)(char *filter_result)) {
	assert(name != NULL);

	greshunkel_filter new_filter = {
		.filter_func = filter_func,
		.clean_up = clean_up,
		.name = {0}
	};
	strncpy(new_filter.name, name, sizeof(new_filter.name) - 1);

	vector_append(ctext->filter_functions, &new_filter, sizeof(struct greshunkel_filter));
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
testq %rsi, %rsi
je 0x1e82
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
andq $0x0, 0x18(%r14)
movq %rdx, 0x20(%r14)
movq %rcx, 0x28(%r14)
pushq $0x1f
popq %rdx
movq %r14, %rdi
callq 0x1050
movq 0x8(%rbx), %rdi
pushq $0x30
popq %rdx
movq %r14, %rsi
callq 0x43d2
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x48ca(%rip), %rdi      # 0x6753
leaq 0x43ae(%rip), %rsi      # 0x623e
leaq 0x448d(%rip), %rcx      # 0x6324
pushq $0x68
popq %rdx
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel.c
// Function: gshkl_add_string
int gshkl_add_string(greshunkel_ctext *ctext, const char name[const], const char value[const]) {
	assert(ctext != NULL);
	assert(name != NULL);
	assert(value != NULL);

	/* Create a new tuple to hold type and name and shit. */
	greshunkel_tuple _stack_tuple = {
		.name = {0},
		.type = GSHKL_STR,
		.value =  {{0}}
	};
	strncpy(_stack_tuple.name, name, WISDOM_OF_WORDS - 1);

	/* Copy the value of the string into the var object: */
	greshunkel_var _stack_var = {{0}};
	if (value != NULL)
		strncpy(_stack_var.str, value, MAX_GSHKL_STR_SIZE);
	_stack_var.str[MAX_GSHKL_STR_SIZE] = '\0';

	/* Copy the var object itself into the tuple's var space: */
	memcpy(&_stack_tuple.value, &_stack_var, sizeof(greshunkel_var));

	/* Push that onto our values stack. */
	return _gshkl_add_var_to_context(ctext, &_stack_tuple);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
testq %rdi, %rdi
je 0x1f39
testq %rsi, %rsi
je 0x1f52
movq %rdx, %r14
testq %rdx, %rdx
je 0x1f6b
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r15
movups %xmm0, 0x18(%r15)
movl $0x1, 0x20(%r15)
pushq $0x1f
popq %rdx
movq %r15, %rdi
callq 0x1050
leaq 0x230(%rsp), %r12
andq $0x0, 0x200(%r12)
movl $0x200, %edx            # imm = 0x200
movq %r12, %rdi
movq %r14, %rsi
callq 0x1050
leaq 0x28(%rsp), %rdi
movl $0x208, %edx            # imm = 0x208
movq %r12, %rsi
callq 0x1190
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1e24
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x42f0(%rip), %rdi      # 0x6230
leaq 0x42f7(%rip), %rsi      # 0x623e
leaq 0x443d(%rip), %rcx      # 0x638b
pushq $0x76
jmp 0x1f82
leaq 0x47fa(%rip), %rdi      # 0x6753
leaq 0x42de(%rip), %rsi      # 0x623e
leaq 0x4424(%rip), %rcx      # 0x638b
pushq $0x77
jmp 0x1f82
leaq 0x4468(%rip), %rdi      # 0x63da
leaq 0x42c5(%rip), %rsi      # 0x623e
leaq 0x440b(%rip), %rcx      # 0x638b
pushq $0x78
popq %rdx
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel.c
// Function: gshkl_add_int
int gshkl_add_int(greshunkel_ctext *ctext, const char name[const], const int value) {
	assert(ctext != NULL);
	assert(name != NULL);

	greshunkel_tuple _stack_tuple = {
		.name = {0},
		.type = GSHKL_STR,
		.value = {{0}}
	};
	strncpy(_stack_tuple.name, name, WISDOM_OF_WORDS - 1);

	greshunkel_var _stack_var = {{0}};
	snprintf(_stack_var.str, MAX_GSHKL_STR_SIZE, "%i", value);

	memcpy(&_stack_tuple.value, &_stack_var, sizeof(greshunkel_var));

	return _gshkl_add_var_to_context(ctext, &_stack_tuple);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
testq %rdi, %rdi
je 0x2036
movq %rsi, %r15
testq %rsi, %rsi
je 0x2055
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movl $0x218, %edx            # imm = 0x218
movq %r14, %rdi
xorl %esi, %esi
callq 0x1120
movl $0x1, 0x8(%r14)
movq %rsp, %r14
pushq $0x1f
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1050
leaq 0x230(%rsp), %r15
movl $0x208, %edx            # imm = 0x208
movq %r15, %rdi
xorl %esi, %esi
callq 0x1120
leaq 0x4961(%rip), %rdx      # 0x695b
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x10f0
leaq 0x28(%rsp), %rdi
movl $0x208, %edx            # imm = 0x208
movq %r15, %rsi
callq 0x1190
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e24
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x41f3(%rip), %rdi      # 0x6230
leaq 0x41fa(%rip), %rsi      # 0x623e
leaq 0x439d(%rip), %rcx      # 0x63e8
movl $0x90, %edx
callq 0x1110
leaq 0x46f7(%rip), %rdi      # 0x6753
leaq 0x41db(%rip), %rsi      # 0x623e
leaq 0x437e(%rip), %rcx      # 0x63e8
movl $0x91, %edx
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel.c
// Function: gshkl_add_array
greshunkel_var gshkl_add_array(greshunkel_ctext *ctext, const char name[]) {
	assert(ctext != NULL);

	greshunkel_tuple _stack_tuple = {
		.name = {0},
		.type = GSHKL_ARR,
		.value = {
			.arr = vector_new(sizeof(greshunkel_tuple), 16)
		}
	};
	const size_t name_len = strnlen(name, WISDOM_OF_WORDS) < WISDOM_OF_WORDS ? strnlen(name, WISDOM_OF_WORDS) : WISDOM_OF_WORDS;
	strncpy(_stack_tuple.name, name, name_len);

	_gshkl_add_var_to_context(ctext, &_stack_tuple);
	return _stack_tuple.value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
testq %rsi, %rsi
je 0x2115
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
leaq 0x8(%rsp), %r13
movl $0x230, %edx            # imm = 0x230
movq %r13, %rdi
xorl %esi, %esi
callq 0x1120
pushq $0x10
popq %rsi
movl $0x230, %edi            # imm = 0x230
callq 0x438c
movq %rax, 0x28(%r13)
pushq $0x20
popq %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x1130
cmpq $0x20, %rax
cmovbq %rax, %rbp
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1050
movq %r15, %rdi
movq %r13, %rsi
callq 0x1e24
movl $0x208, %edx            # imm = 0x208
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1190
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4114(%rip), %rdi      # 0x6230
leaq 0x411b(%rip), %rsi      # 0x623e
leaq 0x4302(%rip), %rcx      # 0x642c
movl $0xa3, %edx
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel.c
// Function: gshkl_add_int_to_loop
int gshkl_add_int_to_loop(greshunkel_var *loop, const int value) {
	assert(loop != NULL);

	greshunkel_tuple _stack_tuple = {
		.name = {0},
		.type = GSHKL_STR,
		.value = {{0}}
	};

	greshunkel_var _stack_var = {{0}};
	snprintf(_stack_var.str, MAX_GSHKL_STR_SIZE, "%i", value);

	memcpy(&_stack_tuple.value, &_stack_var, sizeof(greshunkel_var));

	return _gshkl_add_var_to_loop(loop, &_stack_tuple);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
testq %rdi, %rdi
je 0x21c2
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x28(%rsp), %r14
movaps %xmm0, -0x18(%r14)
movaps %xmm0, -0x28(%r14)
andq $0x0, -0x8(%r14)
movl $0x1, -0x8(%r14)
leaq 0x230(%rsp), %r15
movl $0x208, %edx            # imm = 0x208
movq %r15, %rdi
xorl %esi, %esi
callq 0x1120
leaq 0x47d3(%rip), %rdx      # 0x695b
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x10f0
movl $0x208, %edx            # imm = 0x208
movq %r14, %rdi
movq %r15, %rsi
callq 0x1190
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x21e1
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x42a4(%rip), %rdi      # 0x646d
leaq 0x406e(%rip), %rsi      # 0x623e
leaq 0x42a3(%rip), %rcx      # 0x647a
movl $0xb4, %edx
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel.c
// Function: gshkl_add_sub_context_to_loop
int gshkl_add_sub_context_to_loop(greshunkel_var *loop, const greshunkel_ctext *ctext) {
	assert(loop != NULL);
	assert(ctext != NULL);

	greshunkel_tuple _stack_tuple = {
		.name = {0},
		.type = GSHKL_SUBCTEXT,
		.value = {
			.sub_ctext = ctext
		}
	};

	return _gshkl_add_var_to_loop(loop, &_stack_tuple);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
testq %rdi, %rdi
je 0x224c
movq %rsi, %r14
testq %rsi, %rsi
je 0x226b
movq %rdi, %rbx
movq %rsp, %r15
movl $0x230, %edx            # imm = 0x230
movq %r15, %rdi
xorl %esi, %esi
callq 0x1120
movl $0x2, 0x20(%r15)
movq %r14, 0x28(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e1
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
leaq 0x421a(%rip), %rdi      # 0x646d
leaq 0x3fe4(%rip), %rsi      # 0x623e
leaq 0x4250(%rip), %rcx      # 0x64b1
movl $0xc5, %edx
callq 0x1110
leaq 0x3fbe(%rip), %rdi      # 0x6230
leaq 0x3fc5(%rip), %rsi      # 0x623e
leaq 0x4231(%rip), %rcx      # 0x64b1
movl $0xc6, %edx
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/greshunkel.c
// Function: gshkl_add_string_to_loop
int gshkl_add_string_to_loop(greshunkel_var *loop, const char *value) {
	assert(loop != NULL);

	greshunkel_tuple _stack_tuple = {
		.name = {0},
		.type = GSHKL_STR,
		.value = {{0}}
	};

	greshunkel_var _stack_var = {{0}};
	if (value != NULL)
		strncpy(_stack_var.str, value, MAX_GSHKL_STR_SIZE);
	_stack_var.str[MAX_GSHKL_STR_SIZE] = '\0';

	memcpy(&_stack_tuple.value, &_stack_var, sizeof(union greshunkel_var));

	return _gshkl_add_var_to_loop(loop, &_stack_tuple);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
testq %rdi, %rdi
je 0x231f
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
andq $0x0, 0x20(%rsp)
movl $0x1, 0x20(%rsp)
leaq 0x230(%rsp), %rdi
movl $0x208, %edx            # imm = 0x208
xorl %esi, %esi
callq 0x1120
testq %r14, %r14
je 0x22eb
leaq 0x230(%rsp), %rdi
movl $0x200, %edx            # imm = 0x200
movq %r14, %rsi
callq 0x1050
leaq 0x230(%rsp), %rsi
movb $0x0, 0x200(%rsi)
leaq 0x28(%rsp), %rdi
movl $0x208, %edx            # imm = 0x208
callq 0x1190
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x21e1
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r14
retq
leaq 0x4147(%rip), %rdi      # 0x646d
leaq 0x3f11(%rip), %rsi      # 0x623e
leaq 0x41cb(%rip), %rcx      # 0x64ff
movl $0xd4, %edx
callq 0x1110