LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/printenv.c
// Function: main
int main(int argc, char **argv){
    char *var;
    int ret = 0;
    if(argc == 1){
        for(int i = 0; environ[i] != NULL; i++){
            puts(environ[i]);
        }
    }
    else if(!strcmp(argv[1], "-0") || !strcmp(argv[1], "--null")){
        for(int i = 2; i < argc; i++){
            var = getenv(argv[i]);
            if(var == NULL){
                ret = 1;
                continue;
            }
            else {
                fprintf(stdout, "%s", var);
                putchar('\0');
            }
        }
    }
    else {
        for(int i = 1; i < argc; i++){
            var = getenv(argv[i]);
            if(var == NULL){
                ret = 1;
                continue;
            }
            else {
                fprintf(stdout, "%s\n", var);
            }
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x11e6
movl $0x0, -0x20(%rbp)
movq 0x2e37(%rip), %rax      # 0x3fe8
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x11e1
movq 0x2e22(%rip), %rax      # 0x3fe8
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1050
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x11aa
jmp 0x12df
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe0f(%rip), %rsi       # 0x2004
callq 0x1060
cmpl $0x0, %eax
je 0x1218
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xdf9(%rip), %rsi       # 0x2007
callq 0x1060
cmpl $0x0, %eax
jne 0x127e
movl $0x2, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x127c
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x124c
movl $0x1, -0x1c(%rbp)
jmp 0x1271
movq 0x2d85(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0xdad(%rip), %rsi       # 0x200e
movb $0x0, %al
callq 0x1070
xorl %edi, %edi
callq 0x1040
jmp 0x1271
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x121f
jmp 0x12dd
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x12db
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12b2
movl $0x1, -0x1c(%rbp)
jmp 0x12d0
movq 0x2d1f(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0xd4a(%rip), %rsi       # 0x2011
movb $0x0, %al
callq 0x1070
jmp 0x12d0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1285
jmp 0x12dd
jmp 0x12df
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_advert_create
int EXPORTED
obstcp_advert_create(uint8_t *output, unsigned length,
                            const struct obstcp_keys *keys, ...) {
  va_list ap;
  va_start(ap, keys);

  const int r = advert_create(output, length, keys, ap);
  va_end(ap);

  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x14eb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x18, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x1550
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_advert_base32_create
int EXPORTED
obstcp_advert_base32_create(char *output, unsigned length,
                            const struct obstcp_keys *keys, ...) {
  uint8_t advert[384];
  va_list ap;
  va_start(ap, keys);

  const int ret = advert_create(advert, sizeof(advert), keys, ap);
  va_end(ap);

  if (ret > sizeof(advert)) {
    goto spc;
  } else if (ret == -1) {
    return -1;
  }

  const unsigned outlen = base32_encode_length(ret);
  if (outlen <= length) {
    base32_encode(output, advert, ret);
  }
  return outlen;

 spc:
  errno = E2BIG;
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
testb %al, %al
je 0x18b7
movaps %xmm0, -0x250(%rbp)
movaps %xmm1, -0x240(%rbp)
movaps %xmm2, -0x230(%rbp)
movaps %xmm3, -0x220(%rbp)
movaps %xmm4, -0x210(%rbp)
movaps %xmm5, -0x200(%rbp)
movaps %xmm6, -0x1f0(%rbp)
movaps %xmm7, -0x1e0(%rbp)
movq %r9, -0x258(%rbp)
movq %r8, -0x260(%rbp)
movq %rcx, -0x268(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x1c0(%rbp), %rax
leaq -0x280(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
leaq -0x1a0(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x1c0(%rbp), %rcx
movl $0x180, %esi            # imm = 0x180
callq 0x1550
movl %eax, -0x1c4(%rbp)
leaq -0x1c0(%rbp), %rax
movslq -0x1c4(%rbp), %rax
cmpq $0x180, %rax            # imm = 0x180
jbe 0x1938
jmp 0x1989
cmpl $-0x1, -0x1c4(%rbp)
jne 0x194a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x199b
jmp 0x194c
movl -0x1c4(%rbp), %edi
callq 0x9f90
movl %eax, -0x1c8(%rbp)
movl -0x1c8(%rbp), %eax
cmpl -0x14(%rbp), %eax
ja 0x197e
movq -0x10(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
movl -0x1c4(%rbp), %edx
callq 0x9fb0
movl -0x1c8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x199b
callq 0x1050
movl $0x7, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_advert_parse
int EXPORTED
obstcp_advert_parse(const uint8_t *input, unsigned length, ...) {
  va_list ap;
  va_start(ap, length);

  const int r = advert_parse(input, length, ap);
  va_end(ap);

  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x19eb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x1a50
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_advert_base32_parse
int EXPORTED
obstcp_advert_base32_parse(const char *input, unsigned length, ...) {
  va_list ap;
  va_start(ap, length);
  uint8_t advert[384];
  const unsigned decoded_length = base32_decode_length(length);

  if (decoded_length > sizeof(advert)) return 0;
  if (!base32_decode(advert, input, length)) return 0;

  const int r = advert_parse(advert, decoded_length, ap);
  va_end(ap);

  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
testb %al, %al
je 0x1d67
movaps %xmm0, -0x240(%rbp)
movaps %xmm1, -0x230(%rbp)
movaps %xmm2, -0x220(%rbp)
movaps %xmm3, -0x210(%rbp)
movaps %xmm4, -0x200(%rbp)
movaps %xmm5, -0x1f0(%rbp)
movaps %xmm6, -0x1e0(%rbp)
movaps %xmm7, -0x1d0(%rbp)
movq %r9, -0x248(%rbp)
movq %r8, -0x250(%rbp)
movq %rcx, -0x258(%rbp)
movq %rdx, -0x260(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x270(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl -0x14(%rbp), %edi
callq 0x9e80
movl %eax, -0x1b4(%rbp)
movl -0x1b4(%rbp), %eax
cmpq $0x180, %rax            # imm = 0x180
jbe 0x1dd3
movl $0x0, -0x4(%rbp)
jmp 0x1e1d
leaq -0x1b0(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x9e90
cmpl $0x0, %eax
jne 0x1df4
movl $0x0, -0x4(%rbp)
jmp 0x1e1d
leaq -0x1b0(%rbp), %rdi
movl -0x1b4(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x1a50
movl %eax, -0x1b8(%rbp)
leaq -0x30(%rbp), %rax
movl -0x1b8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: buffer_put
static int
buffer_put(uint8_t *out, unsigned length, unsigned *offset,
           const void *in, unsigned inlen) {
  if (*offset + inlen > length) return 0;
  memcpy(out + *offset, in, inlen);
  (*offset) += inlen;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
addl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x2092
movl $0x0, -0x4(%rbp)
jmp 0x20bf
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
callq 0x10d0
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_advert_hostent_extract
int EXPORTED
obstcp_advert_hostent_extract(char *output, unsigned *outlen,
                              const struct hostent *hent) {
  unsigned i;

  for (i = 0; hent->h_aliases[i]; ++i) {
      if (!obstcp_advert_cname_extract(output, outlen, hent->h_aliases[i])) {
        if (errno != EEXIST)
          return 0;
      } else {
        return 1;
      }
  }

  if (hent->h_name) {
    return obstcp_advert_cname_extract(output, outlen, hent->h_name);
  } else {
    errno = EEXIST;
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x2149
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
callq 0x1e30
cmpl $0x0, %eax
jne 0x2133
callq 0x1050
cmpl $0x11, (%rax)
je 0x2131
movl $0x0, -0x4(%rbp)
jmp 0x217e
jmp 0x213c
movl $0x1, -0x4(%rbp)
jmp 0x217e
jmp 0x213e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x20eb
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x216c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x1e30
movl %eax, -0x4(%rbp)
jmp 0x217e
callq 0x1050
movl $0x11, (%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/libobstcp.c
// Function: obstcp_advert_cname_encode
void EXPORTED
obstcp_advert_cname_encode(char *output,
                           const char *advert, unsigned advertlen) {
  unsigned i = 0, j = 0;  // i indexes @advert, j indexes @output

  while (advertlen) {
    memcpy(output + j, kDNSMagic, kDNSMagicLen);
    j += kDNSMagicLen;
    unsigned todo = advertlen;
    if (todo > kDNSCharsPerLabel)
      todo = kDNSCharsPerLabel;
    memcpy(output + j, advert + i, todo);
    i += todo;
    j += todo;
    advertlen -= todo;
    output[j++] = '.';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2276
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0xceaf(%rip), %rdx      # 0xf0a8
movl (%rdx), %esi
movl %esi, (%rax,%rcx)
movb 0x4(%rdx), %dl
movb %dl, 0x4(%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x5, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x3a, -0x20(%rbp)
jbe 0x2221
movl $0x3a, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
addq %rax, %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x10d0
movl -0x20(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movl %ecx, %ecx
movb $0x2e, (%rax,%rcx)
jmp 0x21e1
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_keys_key_add
int EXPORTED
obstcp_keys_key_add(struct obstcp_keys *keys, const uint8_t *private_key) {
  struct obstcp_keypair *kp, *a;
  static const uint8_t basepoint[32] = {9};

  kp = (struct obstcp_keypair *) malloc(sizeof(struct obstcp_keypair));
  if (!kp) {
    errno = ENOMEM;
    return 0;
  }

  memcpy(kp->private_key, private_key, 32);
  kp->private_key[0] &= 248;
  kp->private_key[31] &= 127;
  kp->private_key[31] |= 64;

  curve25519(kp->public_key, kp->private_key, basepoint);

  kp->keyid = key_keyid(kp->public_key);

  for (a = keys->keys; a; a = a->next) {
    if (a->keyid == kp->keyid) {
      free(kp);
      errno = ENOSPC;
      return 0;
    }
  }


  kp->next = keys->keys;
  keys->keys = kp;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x50, %edi
callq 0x10e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x22ec
callq 0x1050
movl $0xc, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x23db
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movzbl (%rax), %ecx
andl $0xf8, %ecx
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movzbl 0x1f(%rax), %ecx
andl $0x7f, %ecx
movb %cl, 0x1f(%rax)
movq -0x20(%rbp), %rax
movzbl 0x1f(%rax), %ecx
orl $0x40, %ecx
movb %cl, 0x1f(%rax)
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
leaq 0x9d70(%rip), %rdx      # 0xc0c0
callq 0xa380
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x23f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x23ba
movq -0x28(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jne 0x23aa
movq -0x20(%rbp), %rdi
callq 0x1030
callq 0x1050
movl $0x1c, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x23db
jmp 0x23ac
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2376
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -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: key_keyid
static uint32_t
key_keyid(const uint8_t *key) {
  uint32_t keyid = 0;
  unsigned i;

  for (i = 0; i < 8; ++i) {
    keyid ^= ((const uint32_t *) key)[i];
  }

  return keyid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jae 0x2427
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl (%rax,%rcx,4), %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2406
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_keys_free
void EXPORTED
obstcp_keys_free(struct obstcp_keys *keys) {
  struct obstcp_keypair *kp, *next;

  for (kp = keys->keys; kp; kp = next) {
    next = kp->next;
    free(kp);
  }

  keys->keys = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x246d
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2447
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/./cursor.h
// Function: cursor_has
static int MAYBEUNUSED
cursor_has(struct obstcp_cursor *c, size_t n) {
  struct cursor_has_state s;
  s.n = n;
  s.found = 0;

  c->fold(c, cursor_has_f, &s);
  return s.found >= n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
leaq 0x26cd(%rip), %rsi      # 0x4e80
leaq -0x20(%rbp), %rdx
callq *%rax
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/./cursor.h
// Function: cursor_read
static const uint8_t * MAYBEUNUSED
cursor_read(uint8_t *buffer, struct obstcp_cursor *c, size_t n) {
  struct iovec iov;

  if (!c->get(c, &iov, n))
    abort();

  if (iov.iov_len == n)
    return (const uint8_t *) iov.iov_base;

  size_t j = 0;
  while (n) {
    memcpy(buffer + j, iov.iov_base, iov.iov_len);
    n -= iov.iov_len;
    j += iov.iov_len;
    if (!c->get(c, &iov, n))
      abort();
  }

  return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x2803
callq 0x1040
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x2817
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x287f
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2877
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x10d0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x2875
callq 0x1040
jmp 0x281f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: keys_private_key_get
static const uint8_t *
keys_private_key_get(const struct obstcp_keys *keys, uint32_t keyid) {
  struct obstcp_keypair *kp;

  for (kp = keys->keys; kp; kp = kp->next) {
    if (kp->keyid == keyid) return kp->private_key;
  }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2b43
movq -0x20(%rbp), %rax
movl 0x40(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x2b33
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b4b
jmp 0x2b35
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2b16
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: server_setup
static void
server_setup(struct obstcp_server_ctx *ctx, const uint8_t *shared,
             const uint8_t *random) {
  uint8_t in_key[32], out_key[32];
  struct sha256_ctx sha;

  sha256_init(&sha);
  sha256_update(&sha, shared, 32);
  sha256_update(&sha, random, 16);
  sha256_final(&sha, in_key);

  sha256_init(&sha);
  sha256_update(&sha, shared, 32);
  sha256_update(&sha, in_key, 32);
  sha256_final(&sha, out_key);

  ctx->state = SRV_ST_FIRST_FRAME;
  memset(&ctx->u.b.in, 0, sizeof(struct obstcp_half_connection));
  memset(&ctx->u.b.out, 0, sizeof(struct obstcp_half_connection));

  memcpy(ctx->u.b.in.key, in_key, 32);
  memcpy(ctx->u.b.out.key, out_key, 32);

  ctx->u.b.in.used = 64;
  ctx->u.b.out.used = 64;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x5ae0
movq -0x10(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
movl $0x20, %edx
callq 0x5b60
movq -0x18(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
movl $0x10, %edx
callq 0x5b60
leaq -0x40(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x9c40
leaq -0xd0(%rbp), %rdi
callq 0x5ae0
movq -0x10(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
movl $0x20, %edx
callq 0x5b60
leaq -0x40(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
movl $0x20, %edx
callq 0x5b60
leaq -0x60(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x9c40
movq -0x8(%rbp), %rax
movl $0x1, 0x190(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x74, %edx
callq 0x10a0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x74, %rdi
xorl %esi, %esi
movl $0x74, %edx
callq 0x10a0
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x4c(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x54(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x5c(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x64(%rax)
movq -0x8(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0xc0(%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0xc8(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0xd0(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rax
movl $0x40, 0x48(%rax)
movq -0x8(%rbp), %rax
movl $0x40, 0xbc(%rax)
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/./iovec_cursor.h
// Function: iovec_cursor_init
static void MAYBEUNUSED
iovec_cursor_init(struct iovec_cursor *c,
                  struct iovec *iov, unsigned count) {
  c->c.get = iovec_cursor_get_;
  c->c.fold = iovec_cursor_fold;
  c->iov = iov;
  c->count = count;
  c->i = 0;
  c->j = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
leaq 0x21f6(%rip), %rcx      # 0x4ed0
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq 0x22e8(%rip), %rcx      # 0x4fd0
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/./iovec_cursor.h
// Function: iovec_cursor_copy_cursor
static void MAYBEUNUSED
iovec_cursor_copy_cursor(struct iovec_cursor *dest, struct obstcp_cursor *src) {
  while (!iovec_cursor_full(dest)) {
    struct iovec iov;
    if (!src->get(src, &iov, ULONG_MAX))
      return;

    iovec_cursor_append(dest, iov.iov_base, iov.iov_len);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3f10
cmpb $0x0, %al
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d46
jmp 0x2d78
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movq $-0x1, %rdx
callq *%rax
cmpl $0x0, %eax
jne 0x2d65
jmp 0x2d78
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3f30
jmp 0x2d30
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_server_encrypt
ssize_t EXPORTED
obstcp_server_encrypt(struct obstcp_server_ctx *ctx, uint8_t *output,
                      const uint8_t *buffer, size_t len) {
  obs_encrypt(&ctx->u.b.out, output, buffer, len);
  if (!ctx->frame_valid && ctx->state == SRV_ST_2ND_FRAME_PENDING) {
    ctx->state = SRV_ST_RUNNING;
  }

  ctx->frame_valid = 1;

  return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x74, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2d80
movq -0x8(%rbp), %rax
cmpb $0x0, 0x195(%rax)
jne 0x2fcd
movq -0x8(%rbp), %rax
cmpl $0x2, 0x190(%rax)
jne 0x2fcd
movq -0x8(%rbp), %rax
movl $0x3, 0x190(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x195(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_server_prefix
int EXPORTED
obstcp_server_prefix(struct obstcp_server_ctx *ctx, struct iovec *prefix) {
  static const uint8_t banner[2] = {0, 0};

  if (!ctx->frame_valid) return -1;

  if (ctx->state == SRV_ST_FIRST_FRAME) {
    prefix->iov_base = (void *) banner;
    prefix->iov_len = 2;
    ctx->state = SRV_ST_2ND_FRAME_PENDING;
    return 1;
  } else {
    prefix->iov_len = 0;
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x195(%rax)
jne 0x3012
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3063
movq -0x10(%rbp), %rax
cmpl $0x1, 0x190(%rax)
jne 0x3050
movq -0x18(%rbp), %rax
leaq 0x90b6(%rip), %rcx      # 0xc0e0
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x2, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x2, 0x190(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3063
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: client_write_banner
static unsigned
client_write_banner(uint8_t *banner, unsigned len, const struct obstcp_keypair *kp,
                    const uint8_t *random, const uint8_t *serverpublic) {
  unsigned j = 2;
  const uint32_t keyid = htonl(key_keyid(serverpublic));

  if (!varint_put(banner, len, &j, OBSTCP_KIND_PUBLIC << 1 | 1)) goto spc;
  if (!varint_put(banner, len, &j, 32)) goto spc;
  if (!buffer_put(banner, len, &j, kp->public_key, 32)) goto spc;

  if (!varint_put(banner, len, &j, OBSTCP_KIND_NONCE << 1 | 1)) goto spc;
  if (!varint_put(banner, len, &j, 16)) goto spc;
  if (!buffer_put(banner, len, &j, random, 16)) goto spc;

  if (!varint_put(banner, len, &j, OBSTCP_KIND_KEYID << 1 | 1)) goto spc;
  if (!varint_put(banner, len, &j, 4)) goto spc;
  if (!buffer_put(banner, len, &j, &keyid, 4)) goto spc;

  const uint16_t blen = j - 2;
  const uint16_t blen_be = htons(blen);
  memcpy(banner, &blen_be, sizeof(blen_be));

  return j;

 spc:
   // This is a programming error in this library
   abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x2, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x23f0
movl %eax, %edi
callq 0x1090
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x2c(%rbp), %rdx
movl $0x1, %ecx
callq 0x4d50
cmpl $0x0, %eax
jne 0x3504
jmp 0x3631
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x2c(%rbp), %rdx
movl $0x20, %ecx
callq 0x4d50
cmpl $0x0, %eax
jne 0x3523
jmp 0x3631
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rcx
addq $0x20, %rcx
leaq -0x2c(%rbp), %rdx
movl $0x20, %r8d
callq 0x2060
cmpl $0x0, %eax
jne 0x354b
jmp 0x3631
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x2c(%rbp), %rdx
movl $0x5, %ecx
callq 0x4d50
cmpl $0x0, %eax
jne 0x356a
jmp 0x3631
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x2c(%rbp), %rdx
movl $0x10, %ecx
callq 0x4d50
cmpl $0x0, %eax
jne 0x3589
jmp 0x3631
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x2c(%rbp), %rdx
movl $0x10, %r8d
callq 0x2060
cmpl $0x0, %eax
jne 0x35ad
jmp 0x3631
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x2c(%rbp), %rdx
movl $0x3, %ecx
callq 0x4d50
cmpl $0x0, %eax
jne 0x35c9
jmp 0x3631
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x2c(%rbp), %rdx
movl $0x4, %ecx
callq 0x4d50
cmpl $0x0, %eax
jne 0x35e5
jmp 0x3631
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x2c(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl $0x4, %r8d
callq 0x2060
cmpl $0x0, %eax
jne 0x3606
jmp 0x3631
movl -0x2c(%rbp), %eax
subl $0x2, %eax
movw %ax, -0x32(%rbp)
movzwl -0x32(%rbp), %edi
callq 0x1070
movw %ax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movw -0x34(%rbp), %cx
movw %cx, (%rax)
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x1040
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_client_banner
void EXPORTED
obstcp_client_banner(struct obstcp_client_ctx *ctx,
                     struct iovec *out) {
  if (ctx->state != CLI_ST_WRITING) abort();
  out->iov_base = (void *) ctx->buffer;
  out->iov_len = ctx->n;
  ctx->n = 0;

  ctx->state = CLI_ST_READING;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x270(%rax)
je 0x3662
callq 0x1040
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x184(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x184(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x270(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_client_accum_init
void EXPORTED
obstcp_client_accum_init(struct obstcp_accum *ac, struct obstcp_client_ctx *ctx) {
  obstcp_accum_init(ac);
  ac->is_server = 0;
  ac->frame_size = obstcp_client_frame_payload_sz(ctx);
  ac->ctx = ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39c0
movq -0x8(%rbp), %rax
movb $0x0, 0x1bd(%rax)
movq -0x10(%rbp), %rdi
callq 0x3960
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_accum_init
static void
obstcp_accum_init(struct obstcp_accum *ac) {
  unsigned i;

  memset(ac, 0, sizeof(struct obstcp_accum));

  for (i = 0; i < OBSTCP_ACCUM_BUFFERS - 1; ++i) {
    ac->buffers[i].next = i + 1;
  }
  ac->buffers[OBSTCP_ACCUM_BUFFERS - 1].next = 0xff;

  ac->free_head = 0;
  ac->data_head = ac->data_tail = 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1c0, %edx            # imm = 0x1C0
callq 0x10a0
movl $0x0, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jae 0x3a11
movl -0xc(%rbp), %eax
addl $0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
addq $0xa, %rax
movl -0xc(%rbp), %edx
imulq $0x48, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x6(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x39e3
movq -0x8(%rbp), %rax
movb $-0x1, 0x178(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1ba(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x1bc(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x1bb(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_server_accum_init
void EXPORTED
obstcp_server_accum_init(struct obstcp_accum *ac, struct obstcp_server_ctx *ctx) {
  obstcp_accum_init(ac);
  ac->is_server = 1;
  ac->frame_size = obstcp_server_frame_payload_sz(ctx);
  ac->ctx = ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39c0
movq -0x8(%rbp), %rax
movb $0x1, 0x1bd(%rax)
movq -0x10(%rbp), %rdi
callq 0x3070
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x3fd5
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpl 0x18(%rdx), %ecx
movb %al, -0x21(%rbp)
jae 0x3fd5
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
setb %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3fe1
jmp 0x40df
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x20(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x4019
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x1c(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x1c(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x10(%rbp), %rdx
movl 0x1c(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jne 0x40cd
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
jmp 0x3fa0
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/./iovec_cursor.h
// Function: iovec_cursor_get
static void MAYBEUNUSED
iovec_cursor_get(struct iovec *iov, struct iovec_cursor *c, size_t len) {
  assert(!iovec_cursor_full(c));

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f10
cmpb $0x0, %al
jne 0x4113
jmp 0x4132
leaq 0x8121(%rip), %rdi      # 0xc23b
leaq 0x8130(%rip), %rsi      # 0xc251
movl $0x76, %edx
leaq 0x8135(%rip), %rcx      # 0xc262
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x20(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x416a
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x10(%rbp), %rdx
movl 0x1c(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jne 0x41eb
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/libobstcp.c
// Function: obstcp_rbuf_client_init
void EXPORTED
obstcp_rbuf_client_init(struct obstcp_rbuf *rbuf, struct obstcp_client_ctx *ctx) {
  rbuf->ctx = ctx;
  rbuf->is_server = 0;
  varbuf_init(&rbuf->in);
  varbuf_init(&rbuf->out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x4450
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x4450
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x452d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4507
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/./varbuf.h
// Function: varbuf_copy_out
static size_t MAYBEUNUSED
varbuf_copy_out(uint8_t *buffer, size_t len, struct varbuf *vb) {
  struct chunk *c, *next;
  off_t j = 0;

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

    size_t todo = c->used - c->read;
    if (todo > len)
      todo = len;

    memcpy(buffer + j, c->data + c->read, todo);
    len -= todo;
    j += todo;
    c->read += todo;

    if (c->read == c->used) {
      free(c);
      vb->head = next;
      if (!next)
        vb->tail = NULL;
    }
  }

  return j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x491a
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
subq 0x10(%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x4884
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x28, %rsi
movq -0x20(%rbp), %rax
addq 0x10(%rax), %rsi
movq -0x38(%rbp), %rdx
callq 0x10d0
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x490b
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
jne 0x4909
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x490b
jmp 0x490d
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4847
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/./varbuf.h
// Function: varbuf_cursor_init
static void MAYBEUNUSED
varbuf_cursor_init(struct varbuf_cursor *c, const struct varbuf *vb,
                   uint8_t *extra, size_t len) {
  c->c.get = varbuf_cursor_get;
  c->c.fold = varbuf_cursor_fold;
  c->chunk = vb->head;

  c->extra = extra;
  c->used = len;
  c->read = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
leaq 0x8a1(%rip), %rcx       # 0x51f0
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq 0x9e3(%rip), %rcx       # 0x5340
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/./varbuf.h
// Function: varbuf_copy_iovec_cursor
static int MAYBEUNUSED
varbuf_copy_iovec_cursor(struct varbuf *vb, struct iovec_cursor *c) {
  while (!iovec_cursor_full(c)) {
    struct iovec iov;
    iovec_cursor_get(&iov, c, ULONG_MAX);
    if (varbuf_copy_in(vb, iov.iov_base, iov.iov_len) == -1)
      return 0;
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3f10
cmpb $0x0, %al
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x49c6
jmp 0x49fb
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq $-0x1, %rdx
callq 0x40f0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4b00
cmpl $-0x1, %eax
jne 0x49f9
movl $0x0, -0x4(%rbp)
jmp 0x4a02
jmp 0x49b0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/./varbuf.h
// Function: varbuf_discard
static size_t MAYBEUNUSED
varbuf_discard(struct varbuf *vb, size_t n) {
  struct chunk *c, *next;

  for (c = vb->head; c && n; c = next) {
    next = c->next;
    size_t todo = n;
    if (todo > c->used - c->read)
      todo = c->used - c->read;

    c->read += todo;
    n -= todo;

    if (c->read == c->used) {
      vb->head = next;
      if (!next)
        vb->tail = NULL;
      free(c);
    }
  }

  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x29(%rbp)
je 0x4a42
cmpq $0x0, -0x10(%rbp)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x4a4e
jmp 0x4af6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x18(%rbp), %rdx
subq 0x10(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x4a8f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x10(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x4ae7
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x4ade
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x1030
jmp 0x4ae9
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x4a2b
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4bac
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq 0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x4b58
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x10d0
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4c94
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x100, -0x38(%rbp)     # imm = 0x100
jae 0x4bd1
movq $0x100, -0x38(%rbp)     # imm = 0x100
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x10e0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x4c00
callq 0x1050
movl $0xc, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4c9b
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4c68
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4c7b
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10b0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x28(%rbp)
movb %al, -0x29(%rbp)
jne 0x4d3d
callq 0x1050
cmpl $0x4, (%rax)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x4d0c
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jb 0x4d76
movl $0x0, -0x4(%rbp)
jmp 0x4dcb
cmpl $0x7f, -0x24(%rbp)
jbe 0x4d98
movl -0x24(%rbp), %eax
andl $0x7f, %eax
orl $0x80, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movb %dl, (%rax,%rcx)
jmp 0x4daa
movl -0x24(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
shrl $0x7, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x24(%rbp)
jne 0x4d62
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq