LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x4e05
movl $0x0, -0x4(%rbp)
jmp 0x4e75
movl -0x2c(%rbp), %eax
shll $0x7, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
andl $0x7f, %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
xorl %eax, %eax
cmpl $0x4, -0x30(%rbp)
movb %al, -0x31(%rbp)
jae 0x4e5e
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdx
movl (%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rdx)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x4df1
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x4f04
movl $0x0, -0x4(%rbp)
jmp 0x4fc4
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movl 0x1c(%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
subq 0x20(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x4f3c
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movl 0x1c(%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
addq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x28(%rbp), %rdx
movl 0x1c(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jne 0x4fbd
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x50b2
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0x505c
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x30(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rsi
movq -0x28(%rbp), %rcx
addq 0x20(%rcx), %rsi
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x30(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdx
movq -0x28(%rbp), %rcx
subq 0x20(%rcx), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
jmp 0x5094
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x30(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rsi
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x30(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x50a2
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x50b9
jmp 0x50a4
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4ff6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x5145
movq -0x38(%rbp), %rax
movl -0x44(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x40(%rbp), %rax
movl -0x44(%rbp), %ecx
xorl (%rax,%rcx,4), %edx
movq -0x30(%rbp), %rax
movl -0x44(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5114
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x519b
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
shll $0x2, %ecx
addl -0x44(%rbp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movl -0x20(%rbp), %edx
shll $0x2, %edx
addl -0x44(%rbp), %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
shll $0x2, %ecx
addl -0x44(%rbp), %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x514c
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: block_ctr_inc
static void
block_ctr_inc(uint8_t *ctr) {
  unsigned i;

  for (i = 0; i < 16; ++i) {
    ctr[i]++;
    if (ctr[i]) break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jae 0x51e1
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movb (%rax,%rcx), %dl
addb $0x1, %dl
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
je 0x51d4
jmp 0x51e1
jmp 0x51d6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x51af
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x52bb
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq 0x10(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x5245
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x28, %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
addq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0x52b2
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5336
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x532f
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
subq 0x18(%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x52f3
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x28(%rbp), %rax
addq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5336
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x53c0
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x28, %rsi
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
addq 0x10(%rcx), %rsi
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq 0x10(%rcx), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x53b2
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x540a
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x5368
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
subq 0x18(%rcx), %rax
cmpq $0x0, %rax
je 0x53fd
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq 0x20(%rcx), %rsi
movq -0x28(%rbp), %rcx
movq 0x28(%rcx), %rdx
movq -0x28(%rbp), %rcx
subq 0x18(%rcx), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
jmp 0x5404
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/salsa208.c
// Function: store_littleendian
static void store_littleendian(unsigned char *x,uint32 u)
{
  x[0] = u; u >>= 8;
  x[1] = u; u >>= 8;
  x[2] = u; u >>= 8;
  x[3] = u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/sha256.c
// Function: sha256_init
void
sha256_init(struct sha256_ctx *md) {
  md->length = 0;
  md->curlen = 0;
  md->state[0] = 0x6A09E667UL;
  md->state[1] = 0xBB67AE85UL;
  md->state[2] = 0x3C6EF372UL;
  md->state[3] = 0xA54FF53AUL;
  md->state[4] = 0x510E527FUL;
  md->state[5] = 0x9B05688CUL;
  md->state[6] = 0x1F83D9ABUL;
  md->state[7] = 0x5BE0CD19UL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x6a09e667, 0x8(%rax)  # imm = 0x6A09E667
movq -0x8(%rbp), %rax
movl $0xbb67ae85, 0xc(%rax)  # imm = 0xBB67AE85
movq -0x8(%rbp), %rax
movl $0x3c6ef372, 0x10(%rax) # imm = 0x3C6EF372
movq -0x8(%rbp), %rax
movl $0xa54ff53a, 0x14(%rax) # imm = 0xA54FF53A
movq -0x8(%rbp), %rax
movl $0x510e527f, 0x18(%rax) # imm = 0x510E527F
movq -0x8(%rbp), %rax
movl $0x9b05688c, 0x1c(%rax) # imm = 0x9B05688C
movq -0x8(%rbp), %rax
movl $0x1f83d9ab, 0x20(%rax) # imm = 0x1F83D9AB
movq -0x8(%rbp), %rax
movl $0x5be0cd19, 0x24(%rax) # imm = 0x5BE0CD19
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x40, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x5b8b
jmp 0x5ca9
jmp 0x5b8d
cmpl $0x0, -0x14(%rbp)
jbe 0x5ca9
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x5bee
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jb 0x5bee
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x5cb0
movl -0x1c(%rbp), %eax
shll $0x3, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x5ca4
movl -0x14(%rbp), %eax
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rdx
subl 0x28(%rdx), %ecx
cmpl %ecx, %eax
jae 0x5c07
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x5c14
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
subl 0x28(%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2c, %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
movl %eax, %edx
callq 0x10d0
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x5ca2
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x2c, %rsi
callq 0x5cb0
movl -0x1c(%rbp), %eax
shll $0x3, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
jmp 0x5ca4
jmp 0x5b8d
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
cmpq $0x40, %rax
jb 0x9c62
jmp 0x9d99
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
shll $0x3, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rdx)
movl %ecx, %ecx
movb $-0x80, 0x2c(%rax,%rcx)
movq -0x8(%rbp), %rax
cmpl $0x38, 0x28(%rax)
jbe 0x9ce6
jmp 0x9ca0
movq -0x8(%rbp), %rax
cmpl $0x40, 0x28(%rax)
jae 0x9cc6
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rdx)
movl %ecx, %ecx
movb $0x0, 0x2c(%rax,%rcx)
jmp 0x9ca0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x2c, %rsi
callq 0x5cb0
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
jmp 0x9ce8
movq -0x8(%rbp), %rax
cmpl $0x38, 0x28(%rax)
jae 0x9d0e
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rdx)
movl %ecx, %ecx
movb $0x0, 0x2c(%rax,%rcx)
jmp 0x9ce8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x2c, %rsi
addq $0x38, %rsi
callq 0x9da0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x2c, %rsi
callq 0x5cb0
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jae 0x9d99
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl 0x8(%rax,%rcx,4), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
shll $0x2, %eax
movl %eax, %eax
addq %rax, %rsi
callq 0x9df0
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movl 0x8(%rax,%rcx,4), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
addl $0x1, %eax
shll $0x2, %eax
movl %eax, %eax
addq %rax, %rsi
callq 0x9df0
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x9d42
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/sha256.c
// Function: put64_msb
static void
put64_msb(uint64_t length, void *out) {
  uint32_t a, b;
  memcpy(&a, &length, sizeof(a));
  memcpy(&b, ((uint8_t *) &length) + 4, sizeof(b));
  a = htonl(a);
  b = htonl(b);
  memcpy(((uint8_t *) out), &b, sizeof(b));
  memcpy(((uint8_t *) out) + 4, &a, sizeof(a));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
callq 0x1090
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %edi
callq 0x1090
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x9f63
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movsbl (%rax,%rcx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x9ee5
jmp 0x9f6c
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x23ac(%rip), %rax      # 0xc2b0
movb (%rax,%rcx), %al
movb %al, -0x2d(%rbp)
movzbl -0x2d(%rbp), %eax
cmpl $0x1f, %eax
jle 0x9f15
jmp 0x9f6c
movzbl -0x2d(%rbp), %eax
movl -0x2c(%rbp), %ecx
shll %cl, %eax
orl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x5, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x8, -0x2c(%rbp)
jb 0x9f5e
movl -0x28(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x28(%rbp)
jmp 0x9ebf
movl $0x1, -0x4(%rbp)
jmp 0x9f7e
callq 0x1050
movl $0x47, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xa050
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl -0x24(%rbp), %ecx
shll %cl, %eax
orl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x24(%rbp)
cmpl $0x5, -0x24(%rbp)
jb 0xa04e
movl -0x20(%rbp), %eax
andl $0x1f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x230d(%rip), %rax      # 0xc330
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
subl $0x5, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
shrl $0x5, %eax
movl %eax, -0x20(%rbp)
jmp 0xa00c
jmp 0x9fdb
cmpl $0x0, -0x24(%rbp)
je 0xa079
movl -0x20(%rbp), %eax
movl %eax, %ecx
leaq 0x22ce(%rip), %rax      # 0xc330
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/curve25519/donna/smult.c
// Function: fmonty
void __attribute__((visibility ("hidden")))
fmonty(felem *x2,  /* output 2Q */
       felem *x3,  /* output Q + Q' */
       felem *x,    /* input Q */
       felem *xprime,  /* input Q' */
       const felem *qmqp /* input Q - Q' */) {
  felem *const z2 = &x2[5];
  felem *const z3 = &x3[5];
  felem *const z = &x[5];
  felem *const zprime = &xprime[5];
  felem origx[5], origxprime[5], zzz[5], xx[5], zz[5], xxprime[5],
        zzprime[5], zzzprime[5];

  memcpy(origx, x, 5 * sizeof(felem));
  fsum(x, z);
  fdifference_backwards(z, origx);  // does x - z

  memcpy(origxprime, xprime, sizeof(felem) * 5);
  fsum(xprime, zprime);
  fdifference_backwards(zprime, origxprime);
  fmul(xxprime, xprime, z);
  fmul(zzprime, x, zprime);
  memcpy(origxprime, xxprime, sizeof(felem) * 5);
  fsum(xxprime, zzprime);
  fdifference_backwards(zzprime, origxprime);
  fsquare(x3, xxprime);
  fsquare(zzzprime, zzprime);
  fmul(z3, zzzprime, qmqp);

  fsquare(xx, x);
  fsquare(zz, z);
  fmul(x2, xx, zz);
  fdifference_backwards(zz, xx);  // does zz = xx - zz
  fscalar(zzz, zz); // * 121665
  freduce_coefficients(zzz);
  fsum(zzz, xx);
  fmul(z2, zz, zzz);
}

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq %rdx, 0x1b0(%rsp)
movq %rcx, 0x1a8(%rsp)
movq %r8, 0x1a0(%rsp)
movq 0x1c0(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x198(%rsp)
movq 0x1b8(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x190(%rsp)
movq 0x1b0(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x188(%rsp)
movq 0x1a8(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x180(%rsp)
leaq 0x150(%rsp), %rdi
movq 0x1b0(%rsp), %rsi
movl $0x28, %edx
callq 0x10d0
movq 0x1b0(%rsp), %rdi
movq 0x188(%rsp), %rsi
callq 0xa2f0
movq 0x188(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0xad19
leaq 0x120(%rsp), %rdi
movq 0x1a8(%rsp), %rsi
movl $0x28, %edx
callq 0x10d0
movq 0x1a8(%rsp), %rdi
movq 0x180(%rsp), %rsi
callq 0xa2f0
movq 0x180(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0xad19
leaq 0x60(%rsp), %rdi
movq 0x1a8(%rsp), %rsi
movq 0x188(%rsp), %rdx
callq 0xa89c
leaq 0x30(%rsp), %rdi
movq 0x1b0(%rsp), %rsi
movq 0x180(%rsp), %rdx
callq 0xa89c
leaq 0x120(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x28, %edx
callq 0x10d0
leaq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xa2f0
leaq 0x30(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0xad19
movq 0x1b8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xabcc
movq %rsp, %rdi
leaq 0x30(%rsp), %rsi
callq 0xabcc
movq 0x190(%rsp), %rdi
movq %rsp, %rsi
movq 0x1a0(%rsp), %rdx
callq 0xa89c
leaq 0xc0(%rsp), %rdi
movq 0x1b0(%rsp), %rsi
callq 0xabcc
leaq 0x90(%rsp), %rdi
movq 0x188(%rsp), %rsi
callq 0xabcc
movq 0x1c0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0xa89c
leaq 0x90(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0xad19
leaq 0xf0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xae14
leaq 0xf0(%rsp), %rdi
callq 0xae90
leaq 0xf0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0xa2f0
movq 0x198(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0xf0(%rsp), %rdx
callq 0xa89c
addq $0x1c8, %rsp            # imm = 0x1C8
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/curve25519/donna/smult.c
// Function: fsum
static void
fsum(felem *output, const felem *in) {
  output[0] = output[0] + in[0];
  output[1] = output[1] + in[1];
  output[2] = output[2] + in[2];
  output[3] = output[3] + in[3];
  output[4] = output[4] + in[4];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
addq (%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
addq 0x8(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rsp), %rax
addq 0x10(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rsp), %rax
addq 0x18(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rsp), %rax
addq 0x20(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/curve25519/donna/smult.c
// Function: curve25519
int
curve25519(u8 *mypublic, const u8 *secret, const u8 *basepoint) {
  felem bp[5], x[5], z[5], zmone[5];
  uint8_t e[32];
  int i;

  for (i = 0;i < 32;++i) e[i] = secret[i];
  e[0] &= 248;
  e[31] &= 127;
  e[31] |= 64;

  fexpand(bp, basepoint);
  cmult(x, z, e, bp);
  crecip(zmone, z);
  fmul(z, x, zmone);
  fcontract(mypublic, z);
  return 0;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x20, 0xc(%rsp)
jge 0xa3d4
movq 0xf8(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb (%rax,%rcx), %cl
movslq 0xc(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xa3a7
movzbl 0x10(%rsp), %eax
andl $0xf8, %eax
movb %al, 0x10(%rsp)
movzbl 0x2f(%rsp), %eax
andl $0x7f, %eax
movb %al, 0x2f(%rsp)
movzbl 0x2f(%rsp), %eax
orl $0x40, %eax
movb %al, 0x2f(%rsp)
leaq 0xc0(%rsp), %rdi
movq 0xf0(%rsp), %rsi
callq 0xaf11
leaq 0x90(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xc0(%rsp), %rcx
callq 0xafb4
leaq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xa470
leaq 0x60(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xa89c
movq 0x100(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xaf60
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe57(%rip), %rax       # 0x2004
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x11c3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x11ec
leaq 0xe29(%rip), %rdi       # 0x2006
callq 0x1070
movl $0x1, %edi
callq 0x1080
jmp 0x11ee
movq -0x18(%rbp), %rdi
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1220
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
addq $0x13, %rdx
leaq 0xdf9(%rip), %rdi       # 0x2010
movb $0x0, %al
callq 0x1040
jmp 0x11ee
movq -0x18(%rbp), %rdi
callq 0x1050
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x31b6(%rip), %rdi      # 0x61a0
callq 0x21d0
movl %eax, -0x1014(%rbp)
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2130
cmpl $0x0, -0x1014(%rbp)
jl 0x3013
jmp 0x3032
leaq 0x125e(%rip), %rdi      # 0x4278
leaq 0x125f(%rip), %rsi      # 0x4280
movl $0x13, %edx
leaq 0x1262(%rip), %rcx      # 0x428f
callq 0x2120
movl -0x1014(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20c0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x3053
jmp 0x3072
leaq 0x1269(%rip), %rdi      # 0x42c3
leaq 0x121f(%rip), %rsi      # 0x4280
movl $0x14, %edx
leaq 0x1222(%rip), %rcx      # 0x428f
callq 0x2120
movl -0x1014(%rbp), %edi
callq 0x2140
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x30fd(%rip), %rdi      # 0x61a0
movl $0x2, %esi
movb $0x0, %al
callq 0x2210
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x30ba
jmp 0x30d9
leaq 0x11b7(%rip), %rdi      # 0x4278
leaq 0x11b8(%rip), %rsi      # 0x4280
movl $0x1c, %edx
leaq 0x121a(%rip), %rcx      # 0x42ee
callq 0x2120
jmp 0x30db
movl -0xc(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x30db
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq $0x0, -0x10(%rbp)
leaq -0x1d0(%rbp), %rdi
leaq 0x5e7f(%rip), %rsi      # 0x71e0
movl $0x1bd, %edx            # imm = 0x1BD
callq 0x1180
leaq -0x240(%rbp), %rdi
leaq 0x6027(%rip), %rsi      # 0x73a0
movl $0x64, %edx
callq 0x1180
movb $0x0, %al
callq 0x2080
movq %rax, -0x248(%rbp)
movq -0x248(%rbp), %rdi
leaq 0x5c6c(%rip), %rsi      # 0x700b
leaq 0x5c6c(%rip), %rdx      # 0x7012
callq 0x2390
movq -0x248(%rbp), %rdi
leaq 0x5c5e(%rip), %rsi      # 0x7017
leaq 0x5c5e(%rip), %rdx      # 0x701e
callq 0x2390
movq -0x248(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
movl $0x1bc, %edx            # imm = 0x1BC
leaq -0x10(%rbp), %rcx
callq 0x2a60
movq %rax, -0x250(%rbp)
movq -0x248(%rbp), %rdi
callq 0x2970
movq -0x250(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x1160
movl %eax, -0x254(%rbp)
cmpl $0x0, -0x254(%rbp)
je 0x142b
movq -0x250(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x143e
movq -0x250(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x360, %rsp            # imm = 0x360
movq $0x0, -0x10(%rbp)
movq 0x5fa6(%rip), %rax      # 0x7410
movq %rax, -0x30(%rbp)
movq 0x5fa3(%rip), %rax      # 0x7418
movq %rax, -0x28(%rbp)
movq 0x5fa0(%rip), %rax      # 0x7420
movq %rax, -0x20(%rbp)
movl 0x5f9e(%rip), %eax      # 0x7428
movl %eax, -0x18(%rbp)
movb 0x5f99(%rip), %al       # 0x742c
movb %al, -0x14(%rbp)
leaq -0x140(%rbp), %rdi
leaq 0x5f8c(%rip), %rsi      # 0x7430
movl $0x10b, %edx            # imm = 0x10B
callq 0x1180
movb $0x0, %al
callq 0x2080
movq %rax, -0x148(%rbp)
movq -0x148(%rbp), %rdi
leaq 0x5bd2(%rip), %rsi      # 0x709c
leaq 0x5b53(%rip), %rdx      # 0x7024
callq 0x2390
movq -0x148(%rbp), %rsi
leaq -0x350(%rbp), %rdi
leaq 0x5bac(%rip), %rdx      # 0x7097
callq 0x25c0
leaq -0x350(%rbp), %rdi
leaq 0x5b36(%rip), %rsi      # 0x7034
callq 0x28a0
leaq -0x350(%rbp), %rdi
leaq 0x5b80(%rip), %rsi      # 0x7091
callq 0x28a0
leaq -0x350(%rbp), %rdi
leaq 0x6d18(%rip), %rsi      # 0x823c
callq 0x28a0
leaq -0x350(%rbp), %rdi
movl $0x1, %esi
callq 0x26e0
leaq -0x350(%rbp), %rdi
movl $0x2, %esi
callq 0x26e0
leaq -0x350(%rbp), %rdi
movl $0x3, %esi
callq 0x26e0
movq -0x148(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x1c, %edx
leaq -0x10(%rbp), %rcx
callq 0x2a60
movq %rax, -0x358(%rbp)
movq -0x148(%rbp), %rdi
callq 0x2970
movq -0x358(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x1160
movl %eax, -0x35c(%rbp)
cmpl $0x0, -0x35c(%rbp)
je 0x15bf
movq -0x358(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x15d2
movq -0x358(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x360, %rsp            # imm = 0x360
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq $0x0, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x5f45(%rip), %rsi      # 0x7540
movl $0x38, %edx
callq 0x1180
movb $0x0, %al
callq 0x2080
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
leaq 0x5a1b(%rip), %rsi      # 0x7036
movl $0x1, %edx
callq 0x24c0
movq -0x58(%rbp), %rdi
leaq 0x5a0a(%rip), %rsi      # 0x703a
leaq -0x337(%rip), %rdx      # 0x1300
xorl %eax, %eax
movl %eax, %ecx
callq 0x2300
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x37, %edx
leaq -0x10(%rbp), %rcx
callq 0x2a60
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x2970
movq -0x60(%rbp), %rdi
leaq 0x59d5(%rip), %rsi      # 0x7043
callq 0x1160
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
je 0x168e
movq -0x60(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x169e
movq -0x60(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x56b1(%rip), %rax      # 0x70c0
movq %rax, -0x13(%rbp)
movl 0x56af(%rip), %eax      # 0x70c8
movl %eax, -0xb(%rbp)
movw 0x56a9(%rip), %ax       # 0x70cc
movw %ax, -0x7(%rbp)
movb 0x56a1(%rip), %al       # 0x70ce
movb %al, -0x5(%rbp)
movq 0x66e9(%rip), %rax      # 0x8120
movq %rax, -0x30(%rbp)
movq 0x66e6(%rip), %rax      # 0x8128
movq %rax, -0x28(%rbp)
movl 0x66e4(%rip), %eax      # 0x8130
movl %eax, -0x20(%rbp)
movb $0x0, %al
callq 0x2080
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x566a(%rip), %rsi      # 0x70cf
leaq 0x5753(%rip), %rdx      # 0x71bf
callq 0x2390
movq -0x38(%rbp), %rdi
leaq 0x5659(%rip), %rsi      # 0x70d5
leaq 0x565d(%rip), %rdx      # 0x70e0
callq 0x2390
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x13(%rbp), %rsi
movl $0xe, %edx
leaq -0x40(%rbp), %rcx
callq 0x2a60
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x13, %edx
leaq -0x48(%rbp), %rcx
callq 0x2a60
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2970
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x1160
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
jne 0x1b06
movq -0x50(%rbp), %rdi
callq 0x1030
movq -0x58(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x1b1f
movq -0x50(%rbp), %rdi
callq 0x1030
movq -0x58(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq $0x0, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0x65f5(%rip), %rsi      # 0x8140
movl $0x26, %edx
callq 0x1180
movq 0x5598(%rip), %rax      # 0x70f4
movq %rax, -0x4c(%rbp)
movl 0x5596(%rip), %eax      # 0x70fc
movl %eax, -0x44(%rbp)
movb $0x0, %al
callq 0x2080
movq %rax, -0x58(%rbp)
movb $0x0, %al
callq 0x2080
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
leaq 0x54ee(%rip), %rsi      # 0x7078
leaq 0x54e2(%rip), %rdx      # 0x7073
callq 0x2390
movq -0x60(%rbp), %rdi
leaq 0x555f(%rip), %rsi      # 0x7100
movl $0x1, %edx
callq 0x24c0
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x5515(%rip), %rsi      # 0x70cf
callq 0x2180
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x25, %edx
leaq -0x10(%rbp), %rcx
callq 0x2a60
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
callq 0x2970
movq -0x68(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x1160
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
je 0x1c0a
movq -0x68(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x1c1a
movq -0x68(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
movq $0x0, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
leaq 0x651f(%rip), %rsi      # 0x8170
movl $0x71, %edx
callq 0x1180
leaq -0xc0(%rbp), %rdi
leaq 0x6587(%rip), %rsi      # 0x81f0
movl $0x2f, %edx
callq 0x1180
movb $0x0, %al
callq 0x2080
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rsi
leaq -0x2d0(%rbp), %rdi
leaq 0x546d(%rip), %rdx      # 0x7103
callq 0x25c0
leaq -0x2d0(%rbp), %rdi
leaq 0x5455(%rip), %rsi      # 0x70fe
callq 0x28a0
leaq -0x2d0(%rbp), %rdi
leaq 0x544e(%rip), %rsi      # 0x710a
callq 0x28a0
leaq -0x2d0(%rbp), %rdi
leaq 0x543d(%rip), %rsi      # 0x710c
callq 0x28a0
movq -0xc8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movl $0x70, %edx
leaq -0x10(%rbp), %rcx
callq 0x2a60
movq %rax, -0x2d8(%rbp)
movq -0xc8(%rbp), %rdi
callq 0x2970
movq -0x2d8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x1160
movl %eax, -0x2dc(%rbp)
cmpl $0x0, -0x2dc(%rbp)
je 0x1d3a
movq -0x2d8(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x1d4d
movq -0x2d8(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x18, %esi
callq 0x1150
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x20a4
jmp 0x20c3
leaq 0x6174(%rip), %rdi      # 0x821f
leaq 0x617b(%rip), %rsi      # 0x822d
movl $0x33, %edx
leaq 0x6180(%rip), %rcx      # 0x823e
callq 0x1100
movl $0x230, %edi            # imm = 0x230
movl $0x20, %esi
callq 0x5de0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x20e8
jmp 0x2107
leaq 0x6176(%rip), %rdi      # 0x8265
leaq 0x6137(%rip), %rsi      # 0x822d
movl $0x35, %edx
leaq 0x613c(%rip), %rcx      # 0x823e
callq 0x1100
movl $0x30, %edi
movl $0x8, %esi
callq 0x5de0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x212e
jmp 0x214d
leaq 0x6146(%rip), %rdi      # 0x827b
leaq 0x60f1(%rip), %rsi      # 0x822d
movl $0x37, %edx
leaq 0x60f6(%rip), %rcx      # 0x823e
callq 0x1100
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)