LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tipsy.c
// Function: barycenter
Vec barycenter(Vec p, Vec v1, Vec v2, Vec v3) {
  float d = (v2.y-v3.y) * (v1.x-v3.x) + (v3.x-v2.x) * (v1.y - v3.y);
  float u = ((v2.y-v3.y) * (p.x-v3.x) + (v3.x-v2.x) * (p.y-v3.y)) / d;
  float v = ((v3.y-v1.y) * (p.x-v3.x) + (v1.x-v3.x) * (p.y-v3.y)) / d;
  float w = 1.0f - u - v;
  Vec ret = {u, v, w}; return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x28, %rsp
movlpd %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movlpd %xmm2, -0x48(%rbp)
movss %xmm3, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movlpd %xmm4, -0x68(%rbp)
movss %xmm5, -0x60(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movlpd %xmm6, -0x88(%rbp)
movss %xmm7, -0x80(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
movss -0x58(%rbp), %xmm5
movss -0x54(%rbp), %xmm0
movss -0x78(%rbp), %xmm1
movss -0x74(%rbp), %xmm4
subss %xmm4, %xmm0
movss -0x38(%rbp), %xmm2
movss -0x34(%rbp), %xmm3
subss %xmm1, %xmm2
subss %xmm5, %xmm1
subss %xmm4, %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x8c(%rbp)
movss -0x58(%rbp), %xmm5
movss -0x54(%rbp), %xmm0
movss -0x78(%rbp), %xmm1
movss -0x74(%rbp), %xmm4
subss %xmm4, %xmm0
movss -0x18(%rbp), %xmm2
movss -0x14(%rbp), %xmm3
subss %xmm1, %xmm2
subss %xmm5, %xmm1
subss %xmm4, %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x8c(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x90(%rbp)
movss -0x78(%rbp), %xmm5
movss -0x74(%rbp), %xmm4
movss -0x38(%rbp), %xmm1
movss -0x34(%rbp), %xmm2
movaps %xmm4, %xmm0
subss %xmm2, %xmm0
movss -0x18(%rbp), %xmm2
movss -0x14(%rbp), %xmm3
subss %xmm5, %xmm2
subss %xmm5, %xmm1
subss %xmm4, %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x8c(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x94(%rbp)
movss -0x90(%rbp), %xmm1
movss 0x3a85(%rip), %xmm0     # 0xf004
subss %xmm1, %xmm0
movss -0x94(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x98(%rbp)
movss -0x90(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x94(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x98(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xa0(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0xa8(%rbp)
movsd -0xa8(%rbp), %xmm0
movss -0xa0(%rbp), %xmm1
addq $0x28, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tipsy.c
// Function: error
static void error(char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  fprintf(stderr, "\n");
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xb845
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x8749(%rip), %rax      # 0x13fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3500
movq 0x8732(%rip), %rax      # 0x13fe0
movq (%rax), %rdi
leaq 0x4d7c(%rip), %rsi      # 0x10634
movb $0x0, %al
callq 0x35c0
movl $0x1, %edi
callq 0x3420
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tipsy.c
// Function: readline
static int readline(char **buf, size_t *buflen, FILE *f) {
  size_t i = 0;
  int ch;
  while ((ch = fgetc(f)) != EOF && ch != '\n') {
    if (ch == '\r') continue;
    if (i + 2 >= *buflen) *buf = realloc(*buf, *buflen = *buflen + 1024);
    (*buf)[i++] = (unsigned char)ch;
  }
  (*buf)[i] = '\0';
  return ch == EOF ? -1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3650
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x25(%rbp)
je 0xb90e
cmpl $0xa, -0x24(%rbp)
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xb917
jmp 0xb97e
cmpl $0xd, -0x24(%rbp)
jne 0xb91f
jmp 0xb8ec
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0xb95b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x400, %rsi            # imm = 0x400
movq -0x10(%rbp), %rax
movq %rsi, (%rax)
callq 0x3680
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax,%rcx)
jmp 0xb8ec
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $-0x1, %edx
cmovel %ecx, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tipsy.c
// Function: mtl_del
void mtl_del(Mtl *mtl) {
  Mtl *next;
  while (mtl != NULL) {
    free(mtl->name);
    if (mtl->map_Ka != NULL) tigrFree(mtl->map_Ka);
    if (mtl->map_Kd != NULL) tigrFree(mtl->map_Kd);
    next = mtl->next;
    free(mtl);
    mtl = next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xba7e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3410
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xba47
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6890
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xba5f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6890
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3410
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xba1c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tipsy.c
// Function: obj_del
void obj_del(Obj *o) {
  mtl_del(o->mtl);
  list_del(o->v);
  list_del(o->vn);
  list_del(o->vt);
  list_del(o->f);
  free(o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xba10
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xaae0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xaae0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xaae0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xaae0
movq -0x8(%rbp), %rdi
callq 0x3410
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tipsy.c
// Function: obj_flip
void obj_flip(Obj *obj) {
  for (int i = 0; i < obj->v->len; i++) {
    Vec *v = (Vec*)list_get(obj->v, i);
    v->y = -v->y;
    v->z = -v->z;
  }
  for (int i = 0; i < obj->vn->len; i++) {
    Vec *vn = (Vec*)list_get(obj->vn, i);
    vn->y = -vn->y;
    vn->z = -vn->z;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0xc44e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xabd0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc3e3
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0xc4c2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0xabd0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x28(%rbp), %rax
movss 0x8(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc455
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tipsy.c
// Function: surface_cmp
int surface_cmp(const void *a, const void *b) {
  Surface sa = *(Surface*)a;
  Surface sb = *(Surface*)b;

  float amaxz = fmaxf(fmaxf(sa.v1.z, sa.v2.z), sa.v3.z);
  float bmaxz = fmaxf(fmaxf(sb.v1.z, sb.v2.z), sb.v3.z);

  int apoints = (sa.v1.z < bmaxz) + (sa.v2.z < bmaxz) + (sa.v3.z < bmaxz);
  int bpoints = (sb.v1.z < amaxz) + (sb.v2.z < amaxz) + (sb.v3.z < amaxz);

  return apoints - bpoints;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movl $0x58, %edx
callq 0x32d0
movq -0x10(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
movl $0x58, %edx
callq 0x32d0
movss -0x60(%rbp), %xmm2
movss -0x54(%rbp), %xmm1
movaps %xmm1, %xmm4
movaps %xmm2, %xmm3
cmpunordss %xmm3, %xmm3
movaps %xmm3, %xmm0
pand %xmm4, %xmm0
maxss %xmm2, %xmm1
pandn %xmm1, %xmm3
por %xmm0, %xmm3
movss -0x48(%rbp), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordss %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
maxss %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movss %xmm0, -0xc4(%rbp)
movss -0xb8(%rbp), %xmm2
movss -0xac(%rbp), %xmm1
movaps %xmm1, %xmm4
movaps %xmm2, %xmm3
cmpunordss %xmm3, %xmm3
movaps %xmm3, %xmm0
pand %xmm4, %xmm0
maxss %xmm2, %xmm1
pandn %xmm1, %xmm3
por %xmm0, %xmm3
movss -0xa0(%rbp), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordss %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
maxss %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movss %xmm0, -0xc8(%rbp)
movss -0x60(%rbp), %xmm1
movss -0xc8(%rbp), %xmm0
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movss -0x54(%rbp), %xmm1
movss -0xc8(%rbp), %xmm0
ucomiss %xmm1, %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movss -0x48(%rbp), %xmm1
movss -0xc8(%rbp), %xmm0
ucomiss %xmm1, %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0xcc(%rbp)
movss -0xb8(%rbp), %xmm1
movss -0xc4(%rbp), %xmm0
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movss -0xac(%rbp), %xmm1
movss -0xc4(%rbp), %xmm0
ucomiss %xmm1, %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movss -0xa0(%rbp), %xmm1
movss -0xc4(%rbp), %xmm0
ucomiss %xmm1, %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0xd0(%rbp)
movl -0xcc(%rbp), %eax
subl -0xd0(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tipsy.c
// Function: shade
int shade(Vec nrm, Vec bc) {
  static Vec lights = {-1, -1, -1};
  Vec var = {vec_dot(lights, nrm), vec_dot(lights, nrm), vec_dot(lights, nrm)};
  float intensity = vec_dot(bc, var);
  return 0xFF * fminf(fmaxf(0.3, intensity), 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movlpd %xmm0, -0x20(%rbp)
movss %xmm1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movlpd %xmm2, -0x40(%rbp)
movss %xmm3, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x80fb(%rip), %eax      # 0x147bc
movl %eax, -0x58(%rbp)
movq 0x80e9(%rip), %rax      # 0x147b4
movq %rax, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movss -0x58(%rbp), %xmm1
movl -0x8(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movsd -0x70(%rbp), %xmm2
movss -0x68(%rbp), %xmm3
callq 0xac60
movss %xmm0, -0x4c(%rbp)
movl 0x80bb(%rip), %eax      # 0x147bc
movl %eax, -0x78(%rbp)
movq 0x80a9(%rip), %rax      # 0x147b4
movq %rax, -0x80(%rbp)
movsd -0x80(%rbp), %xmm0
movss -0x78(%rbp), %xmm1
movl -0x8(%rbp), %eax
movl %eax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movsd -0x90(%rbp), %xmm2
movss -0x88(%rbp), %xmm3
callq 0xac60
movss %xmm0, -0x48(%rbp)
movl 0x806f(%rip), %eax      # 0x147bc
movl %eax, -0x98(%rbp)
movq 0x805a(%rip), %rax      # 0x147b4
movq %rax, -0xa0(%rbp)
movsd -0xa0(%rbp), %xmm0
movss -0x98(%rbp), %xmm1
movl -0x8(%rbp), %eax
movl %eax, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movsd -0xb0(%rbp), %xmm2
movss -0xa8(%rbp), %xmm3
callq 0xac60
movss %xmm0, -0x44(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0xc0(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xc8(%rbp)
movsd -0xc8(%rbp), %xmm0
movss -0xc0(%rbp), %xmm1
movl -0x44(%rbp), %eax
movl %eax, -0xd0(%rbp)
movq -0x4c(%rbp), %rax
movq %rax, -0xd8(%rbp)
movsd -0xd8(%rbp), %xmm2
movss -0xd0(%rbp), %xmm3
callq 0xac60
movss %xmm0, -0xb4(%rbp)
movss -0xb4(%rbp), %xmm1
movss 0x3f90(%rip), %xmm0     # 0x10794
maxss %xmm0, %xmm1
movss 0x27f4(%rip), %xmm0     # 0xf004
minss %xmm0, %xmm1
movss 0x27ec(%rip), %xmm0     # 0xf008
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/repl.c
// Function: main
int main(int argc, char **argv) {
    if (argc == 3 && strcmp(argv[1], "-e") == 0) {
        if (eval(argv[2]) == -1) {
            return 1;
        } else {
            return 0;
        }
    } else if (argc == 1) {
        repl();
        return 0;
    } else {
        printf("Usage: %s\n", argv[0]);
        printf("       %s -e <expression>\n", argv[0]);
        return 1;
    }
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x3, 0x10(%rsp)
jne 0x227d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x2db8(%rip), %rsi      # 0x5004
callq 0x20b0
cmpl $0x0, %eax
jne 0x227d
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x22d0
cmpl $-0x1, %eax
jne 0x2273
movl $0x1, 0x14(%rsp)
jmp 0x22c7
movl $0x0, 0x14(%rsp)
jmp 0x22c7
cmpl $0x1, 0x10(%rsp)
jne 0x2293
callq 0x2340
movl $0x0, 0x14(%rsp)
jmp 0x22c7
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x2d65(%rip), %rdi      # 0x5007
movb $0x0, %al
callq 0x2080
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x2d5a(%rip), %rdi      # 0x5012
movb $0x0, %al
callq 0x2080
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/repl.c
// Function: eval
static int eval(const char *str) {
    int err = 0;
    double r = te_interp(str, &err);
    if (err != 0) {
        printf("Error at position %i\n", err);
        return -1;
    } else {
        printf("%g\n", r);
        return 0;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x3a80
movsd %xmm0, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x2319
movl 0x14(%rsp), %esi
leaq 0x2d25(%rip), %rdi      # 0x502d
movb $0x0, %al
callq 0x2080
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2335
movsd 0x8(%rsp), %xmm0
leaq 0x2d1d(%rip), %rdi      # 0x5043
movb $0x1, %al
callq 0x2080
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/repl.c
// Function: repl
static void repl() {
    while (1) {
        char *line = readline("> ");
        if (line == NULL) {
            break;
        } else if (strcmp(line, "q") == 0 || strcmp(line, "quit") == 0) {
            free(line);
            break;
        }

        if (eval(line) != -1) {
            add_history(line);
        }

        free(line);
    }
}

// Assembly:
pushq %rax
leaq 0x2cff(%rip), %rdi      # 0x5047
callq 0x23c0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x235a
jmp 0x23b3
movq (%rsp), %rdi
leaq 0x2ce5(%rip), %rsi      # 0x504a
callq 0x20b0
cmpl $0x0, %eax
je 0x2384
movq (%rsp), %rdi
leaq 0x2cd2(%rip), %rsi      # 0x504c
callq 0x20b0
cmpl $0x0, %eax
jne 0x238f
movq (%rsp), %rdi
callq 0x2030
jmp 0x23b3
jmp 0x2391
movq (%rsp), %rdi
callq 0x22d0
cmpl $-0x1, %eax
je 0x23a8
movq (%rsp), %rdi
callq 0x2500
movq (%rsp), %rdi
callq 0x2030
jmp 0x2341
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/repl.c
// Function: readline
static char *readline(const char *prompt) {
    fprintf(stderr, "%s", prompt);
    char buf[1024];
    char *line = fgets(buf, sizeof(buf), stdin);
    if (line == NULL && feof(stdin)) {
        return NULL;
    } else if (line == NULL) {
        perror("fgets");
        return NULL;
    }

    size_t len = strlen(line);

    if (len < 1)
        return NULL;

    if (line[len - 1] == '\n') {
        line[len - 1] = '\0';
        len -= 1;
    }

    line = malloc(len + 1);
    strcpy(line, buf);
    return line;
}

// Assembly:
subq $0x428, %rsp            # imm = 0x428
movq %rdi, 0x418(%rsp)
movq 0x4c1a(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
movq 0x418(%rsp), %rdx
leaq 0x2c69(%rip), %rsi      # 0x5051
movb $0x0, %al
callq 0x20c0
leaq 0x10(%rsp), %rdi
movq 0x4bc5(%rip), %rax      # 0x6fc0
movq (%rax), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x20a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x243a
movq 0x4ba4(%rip), %rax      # 0x6fc0
movq (%rax), %rdi
callq 0x20d0
cmpl $0x0, %eax
je 0x243a
movq $0x0, 0x420(%rsp)
jmp 0x24e5
cmpq $0x0, 0x8(%rsp)
jne 0x245f
leaq 0x2c0b(%rip), %rdi      # 0x5054
callq 0x2100
movq $0x0, 0x420(%rsp)
jmp 0x24e5
jmp 0x2461
movq 0x8(%rsp), %rdi
callq 0x2070
movq %rax, (%rsp)
cmpq $0x1, (%rsp)
jae 0x2484
movq $0x0, 0x420(%rsp)
jmp 0x24e5
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x24b7
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq (%rsp), %rax
subq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0x20f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2050
movq 0x8(%rsp), %rax
movq %rax, 0x420(%rsp)
movq 0x420(%rsp), %rax
addq $0x428, %rsp            # imm = 0x428
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martin-decky[P]ichiglyph/transpiler/ig2bf/ig2bf.c
// Function: ichiglyph_opcode_decode
static instruction_t ichiglyph_opcode_decode(ichiglyph_opcode_t opcode)
{
	switch (opcode[0]) {
	case 'l':
		switch (opcode[1]) {
		case 'l':
			return INST_DP_INC;
		case 'I':
			return INST_DP_DEC;
		case '1':
			return INST_JMP_FORWARD;
		default:
			return INST_NOP;
		}
	case 'I':
		switch (opcode[1]) {
		case 'l':
			return INST_VAL_INC;
		case 'I':
			return INST_VAL_DEC;
		case '1':
			return INST_JMP_BACK;
		default:
			return INST_NOP;
		}
	case '1':
		switch (opcode[1]) {
		case 'l':
			return INST_VAL_OUTPUT;
		case 'I':
			return INST_VAL_ACCEPT;
		default:
			return INST_NOP;
		}
	default:
		return INST_NOP;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x31, %eax
je 0x1565
jmp 0x14ad
movl -0x14(%rbp), %eax
subl $0x49, %eax
je 0x151b
jmp 0x14b7
movl -0x14(%rbp), %eax
subl $0x6c, %eax
jne 0x159c
jmp 0x14c5
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x31, %eax
je 0x1503
jmp 0x14d7
movl -0x18(%rbp), %eax
subl $0x49, %eax
je 0x14f7
jmp 0x14e1
movl -0x18(%rbp), %eax
subl $0x6c, %eax
jne 0x150f
jmp 0x14eb
movl $0x0, -0x4(%rbp)
jmp 0x15a3
movl $0x1, -0x4(%rbp)
jmp 0x15a3
movl $0x6, -0x4(%rbp)
jmp 0x15a3
movl $0x8, -0x4(%rbp)
jmp 0x15a3
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x31, %eax
je 0x1553
jmp 0x152d
movl -0x1c(%rbp), %eax
subl $0x49, %eax
je 0x154a
jmp 0x1537
movl -0x1c(%rbp), %eax
subl $0x6c, %eax
jne 0x155c
jmp 0x1541
movl $0x2, -0x4(%rbp)
jmp 0x15a3
movl $0x3, -0x4(%rbp)
jmp 0x15a3
movl $0x7, -0x4(%rbp)
jmp 0x15a3
movl $0x8, -0x4(%rbp)
jmp 0x15a3
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x49, %eax
je 0x158a
jmp 0x1577
movl -0x20(%rbp), %eax
subl $0x6c, %eax
jne 0x1593
jmp 0x1581
movl $0x4, -0x4(%rbp)
jmp 0x15a3
movl $0x5, -0x4(%rbp)
jmp 0x15a3
movl $0x8, -0x4(%rbp)
jmp 0x15a3
movl $0x8, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/nl.c
// Function: nl_connect
int nl_connect(struct nl_sock *sk, int protocol)
{
	int err;
	socklen_t addrlen;

	sk->s_fd = socket(AF_NETLINK, SOCK_RAW, protocol);
	if (sk->s_fd < 0) {
		err = -nl_syserr2nlerr(errno);
		goto errout;
	}

	if (!(sk->s_flags & NL_SOCK_BUFSIZE_SET)) {
		err = nl_socket_set_buffer_size(sk, 0, 0);
		if (err < 0)
			goto errout;
	}

	err = bind(sk->s_fd, (struct sockaddr*) &sk->s_local,
		   sizeof(sk->s_local));
	if (err < 0) {
		err = -nl_syserr2nlerr(errno);
		goto errout;
	}

	addrlen = sizeof(sk->s_local);
	err = getsockname(sk->s_fd, (struct sockaddr *) &sk->s_local,
			  &addrlen);
	if (err < 0) {
		err = -nl_syserr2nlerr(errno);
		goto errout;
	}

	if (addrlen != sizeof(sk->s_local)) {
		err = -NLE_NOADDR;
		goto errout;
	}

	if (sk->s_local.nl_family != AF_NETLINK) {
		err = -NLE_AF_NOSUPPORT;
		goto errout;
	}

	sk->s_proto = protocol;

	return 0;
errout:
	close(sk->s_fd);
	sk->s_fd = -1;

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edx
movl $0x10, %edi
movl $0x3, %esi
callq 0x36d0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jge 0x37fe
callq 0x30a0
movl (%rax), %edi
callq 0x3390
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x38e4
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x382a
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x34b0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x3828
jmp 0x38e4
jmp 0x382a
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl $0xc, %edx
callq 0x3470
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x3867
callq 0x30a0
movl (%rax), %edi
callq 0x3390
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x38e4
movl $0xc, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x3570
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x38aa
callq 0x30a0
movl (%rax), %edi
callq 0x3390
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x38e4
movl -0x1c(%rbp), %eax
cmpq $0xc, %rax
je 0x38bc
movl $0xffffffed, -0x18(%rbp) # imm = 0xFFFFFFED
jmp 0x38e4
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x10, %eax
je 0x38d1
movl $0xfffffff5, -0x18(%rbp) # imm = 0xFFFFFFF5
jmp 0x38e4
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3901
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x3270
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/nl.c
// Function: nl_close
void nl_close(struct nl_sock *sk)
{
	if (sk->s_fd >= 0) {
		close(sk->s_fd);
		sk->s_fd = -1;
	}

	sk->s_proto = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jl 0x393d
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x3270
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/nl.c
// Function: nl_sendto
int nl_sendto(struct nl_sock *sk, void *buf, size_t size)
{
	int ret;

	ret = sendto(sk->s_fd, buf, size, 0, (struct sockaddr *)
		     &sk->s_peer, sizeof(sk->s_peer));
	if (ret < 0)
		return -nl_syserr2nlerr(errno);

	return ret;
}

// 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
movl 0x18(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %r8
xorl %ecx, %ecx
movl $0xc, %r9d
callq 0x3250
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x39b0
callq 0x30a0
movl (%rax), %edi
callq 0x3390
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x39b6
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/nl.c
// Function: nl_sendmsg
int nl_sendmsg(struct nl_sock *sk, struct nl_msg *msg, struct msghdr *hdr)
{
	struct nl_cb *cb;
	int ret;

	struct iovec iov = {
		.iov_base = (void *) nlmsg_hdr(msg),
		.iov_len = nlmsg_hdr(msg)->nlmsg_len,
	};

	hdr->msg_iov = &iov;
	hdr->msg_iovlen = 1;

	nlmsg_set_src(msg, &sk->s_local);

	cb = sk->s_cb;
	if (cb->cb_set[NL_CB_MSG_OUT])
		if (nl_cb_call(cb, NL_CB_MSG_OUT, msg) != NL_OK)
			return 0;

	ret = sendmsg(sk->s_fd, hdr, 0);
	if (ret < 0)
		return -nl_syserr2nlerr(errno);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3a90
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3a90
movl (%rax), %eax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
leaq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x1, 0x18(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3ab0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x3a4e
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x6, %esi
callq 0x3ae0
cmpl $0x0, %eax
je 0x3a4c
movl $0x0, -0x4(%rbp)
jmp 0x3a86
jmp 0x3a4e
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x30f0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x3a80
callq 0x30a0
movl (%rax), %edi
callq 0x3390
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x3a86
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/nl.c
// Function: nl_send
int nl_send(struct nl_sock *sk, struct nl_msg *msg)
{
	struct sockaddr_nl *dst;
	struct ucred *creds;
	
	struct msghdr hdr = {
		.msg_name = (void *) &sk->s_peer,
		.msg_namelen = sizeof(struct sockaddr_nl),
	};

	/* Overwrite destination if specified in the message itself, defaults
	 * to the peer address of the socket.
	 */
	dst = nlmsg_get_dst(msg);
	if (dst->nl_family == AF_NETLINK)
		hdr.msg_name = dst;

	/* Add credentials if present. */
	creds = nlmsg_get_creds(msg);
	if (creds != NULL) {
		char buf[CMSG_SPACE(sizeof(struct ucred))];
		struct cmsghdr *cmsg;

		hdr.msg_control = buf;
		hdr.msg_controllen = sizeof(buf);

		cmsg = CMSG_FIRSTHDR(&hdr);
		cmsg->cmsg_level = SOL_SOCKET;
		cmsg->cmsg_type = SCM_CREDENTIALS;
		cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
		memcpy(CMSG_DATA(cmsg), creds, sizeof(struct ucred));
	}

	return nl_sendmsg(sk, msg, &hdr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x3240
movq -0x8(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x58(%rbp)
movl $0xc, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x10, %eax
jne 0x3b77
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c50
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3c0a
leaq -0x80(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x20, -0x30(%rbp)
cmpq $0x10, -0x30(%rbp)
jb 0x3baf
movq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x3bba
xorl %eax, %eax
movq %rax, -0x90(%rbp)
jmp 0x3bba
movq -0x90(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x88(%rbp), %rax
movl $0x2, 0xc(%rax)
movq -0x88(%rbp), %rax
movq $0x1c, (%rax)
movq -0x88(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x3500
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/nl.c
// Function: nl_send_auto_complete
int nl_send_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
{
	struct nlmsghdr *nlh;
	struct nl_cb *cb = sk->s_cb;

	nlh = nlmsg_hdr(msg);
	if (nlh->nlmsg_pid == 0)
		nlh->nlmsg_pid = sk->s_local.nl_pid;

	if (nlh->nlmsg_seq == 0)
		nlh->nlmsg_seq = sk->s_seq_next++;

	if (msg->nm_protocol == -1)
		msg->nm_protocol = sk->s_proto;
	
	nlh->nlmsg_flags |= NLM_F_REQUEST;

	if (!(sk->s_flags & NL_NO_AUTO_ACK))
		nlh->nlmsg_flags |= NLM_F_ACK;

	if (cb->cb_send_ow)
		return cb->cb_send_ow(sk, msg);
	else
		return nl_send(sk, msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3a90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x3cd1
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x3cf1
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x20(%rax)
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x3d07
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movzwl 0x6(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x3d34
movq -0x20(%rbp), %rax
movzwl 0x6(%rax), %ecx
orl $0x4, %ecx
movw %cx, 0x6(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
je 0x3d5c
movq -0x28(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x3d6c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3430
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/nl.c
// Function: nl_send_simple
int nl_send_simple(struct nl_sock *sk, int type, int flags, void *buf,
		   size_t size)
{
	int err;
	struct nl_msg *msg;

	msg = nlmsg_alloc_simple(type, flags);
	if (!msg)
		return -NLE_NOMEM;

	if (buf && size) {
		err = nlmsg_append(msg, buf, size, NLMSG_ALIGNTO);
		if (err < 0)
			goto errout;
	}
	

	err = nl_send_auto_complete(sk, msg);
errout:
	nlmsg_free(msg);

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x3110
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3db9
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x3e09
cmpq $0x0, -0x20(%rbp)
je 0x3dea
cmpq $0x0, -0x28(%rbp)
je 0x3dea
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x4, %ecx
callq 0x36b0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x3de8
jmp 0x3dfa
jmp 0x3dea
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x35b0
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3640
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/nl.c
// Function: nl_wait_for_ack
int nl_wait_for_ack(struct nl_sock *sk)
{
	int err;
	struct nl_cb *cb;

	cb = nl_cb_clone(sk->s_cb);
	if (cb == NULL)
		return -NLE_NOMEM;

	nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_wait_handler, NULL);
	err = nl_recvmsgs(sk, cb);
	nl_cb_put(cb);

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3440
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x492d
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x496b
movq -0x20(%rbp), %rdi
movl $0x4, %esi
movl $0x3, %edx
leaq 0x3e(%rip), %rcx        # 0x4980
xorl %eax, %eax
movl %eax, %r8d
callq 0x3690
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3190
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3300
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/handlers.c
// Function: nl_cb_alloc
struct nl_cb *nl_cb_alloc(enum nl_cb_kind kind)
{
	int i;
	struct nl_cb *cb;

	if (kind < 0 || kind > NL_CB_KIND_MAX)
		return NULL;

	cb = calloc(1, sizeof(*cb));
	if (!cb)
		return NULL;

	cb->cb_refcnt = 1;

	for (i = 0; i <= NL_CB_TYPE_MAX; i++)
		nl_cb_set(cb, i, kind, NULL, NULL);

	nl_cb_err(cb, kind, NULL, NULL);

	return cb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jb 0x4a37
cmpl $0x3, -0xc(%rbp)
jbe 0x4a41
movq $0x0, -0x8(%rbp)
jmp 0x4abd
movl $0x1, %edi
movl $0xd0, %esi
callq 0x32c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4a65
movq $0x0, -0x8(%rbp)
jmp 0x4abd
movq -0x18(%rbp), %rax
movl $0x1, 0xc8(%rax)
movl $0x0, -0x10(%rbp)
cmpl $0x9, -0x10(%rbp)
jg 0x4aa2
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x3690
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4a7a
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x3600
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/handlers.c
// Function: nl_cb_set
int nl_cb_set(struct nl_cb *cb, enum nl_cb_type type, enum nl_cb_kind kind,
	      nl_recvmsg_msg_cb_t func, void *arg)
{
	if (type < 0 || type > NL_CB_TYPE_MAX)
		return -NLE_RANGE;

	if (kind < 0 || kind > NL_CB_KIND_MAX)
		return -NLE_RANGE;

	if (kind == NL_CB_CUSTOM) {
		cb->cb_set[type] = func;
		cb->cb_args[type] = arg;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jb 0x4af2
cmpl $0x9, -0x14(%rbp)
jbe 0x4afb
movl $0xfffffff8, -0x4(%rbp) # imm = 0xFFFFFFF8
jmp 0x4b3c
cmpl $0x0, -0x18(%rbp)
jb 0x4b07
cmpl $0x3, -0x18(%rbp)
jbe 0x4b10
movl $0xfffffff8, -0x4(%rbp) # imm = 0xFFFFFFF8
jmp 0x4b3c
cmpl $0x3, -0x18(%rbp)
jne 0x4b35
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rdx, 0x50(%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/handlers.c
// Function: nl_cb_err
int nl_cb_err(struct nl_cb *cb, enum nl_cb_kind kind,
	      nl_recvmsg_err_cb_t func, void *arg)
{
	if (kind < 0 || kind > NL_CB_KIND_MAX)
		return -NLE_RANGE;

	if (kind == NL_CB_CUSTOM) {
		cb->cb_err = func;
		cb->cb_err_arg = arg;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jb 0x4b6f
cmpl $0x3, -0x14(%rbp)
jbe 0x4b78
movl $0xfffffff8, -0x4(%rbp) # imm = 0xFFFFFFF8
jmp 0x4ba3
cmpl $0x3, -0x14(%rbp)
jne 0x4b9c
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xa8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/handlers.c
// Function: nl_cb_clone
struct nl_cb *nl_cb_clone(struct nl_cb *orig)
{
	struct nl_cb *cb;
	
	cb = nl_cb_alloc(NL_CB_DEFAULT);
	if (!cb)
		return NULL;

	memcpy(cb, orig, sizeof(*orig));
	cb->cb_refcnt = 1;

	return cb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
xorl %edi, %edi
callq 0x3100
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4bd8
movq $0x0, -0x8(%rbp)
jmp 0x4c00
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xd0, %edx
callq 0x3330
movq -0x18(%rbp), %rax
movl $0x1, 0xc8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/handlers.c
// Function: nl_cb_put
void nl_cb_put(struct nl_cb *cb)
{
	if (!cb)
		return;

	cb->cb_refcnt--;

	if (cb->cb_refcnt < 0)
		BUG();

	if (cb->cb_refcnt <= 0)
		free(cb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4c25
jmp 0x4ca0
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc8(%rax)
jge 0x4c8a
jmp 0x4c47
movq 0x93aa(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x53e9(%rip), %rsi      # 0xa041
leaq 0x53ee(%rip), %rdx      # 0xa04d
movl $0x63, %ecx
movb $0x0, %al
callq 0x32e0
leaq 0x53e6(%rip), %rdi      # 0xa058
leaq 0x53d4(%rip), %rsi      # 0xa04d
movl $0x63, %edx
leaq 0x53d5(%rip), %rcx      # 0xa05a
callq 0x3210
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc8(%rax)
jg 0x4ca0
movq -0x8(%rbp), %rdi
callq 0x3070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_ok
int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
{
	size_t r = remaining;

	return (r >= sizeof(struct nlmsghdr) &&
		nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
		nlh->nlmsg_len <= r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x10, -0x18(%rbp)
movb %al, -0x19(%rbp)
jb 0x4cf2
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq $0x10, %rcx
movb %al, -0x19(%rbp)
jb 0x4cf2
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpq -0x18(%rbp), %rax
setbe %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_parse
int nlmsg_parse(struct nlmsghdr *nlh, int hdrlen, struct nlattr *tb[],
		int maxtype, struct nla_policy *policy)
{
	if (!nlmsg_valid_hdr(nlh, hdrlen))
		return -NLE_MSG_TOOSHORT;

	return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
			 nlmsg_attrlen(nlh, hdrlen), policy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4dc0
cmpl $0x0, %eax
jne 0x4d74
movl $0xffffffeb, -0x4(%rbp) # imm = 0xFFFFFFEB
jmp 0x4db7
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4e10
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4e50
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x38(%rbp), %rdx
movl %eax, %ecx
movq -0x30(%rbp), %r8
callq 0x3370
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_validate
int nlmsg_validate(struct nlmsghdr *nlh, int hdrlen, int maxtype,
		   struct nla_policy *policy)
{
	if (!nlmsg_valid_hdr(nlh, hdrlen))
		return -NLE_MSG_TOOSHORT;

	return nla_validate(nlmsg_attrdata(nlh, hdrlen),
			    nlmsg_attrlen(nlh, hdrlen), maxtype, policy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4dc0
cmpl $0x0, %eax
jne 0x4eb0
movl $0xffffffeb, -0x4(%rbp) # imm = 0xFFFFFFEB
jmp 0x4ee1
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4e10
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4e50
movq -0x28(%rbp), %rdi
movl %eax, %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x35f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/msg.c
// Function: _nlmsg_alloc
static struct nl_msg *__nlmsg_alloc(size_t len)
{
	struct nl_msg *nm;

	nm = calloc(1, sizeof(*nm));
	if (!nm)
		goto errout;

	nm->nm_refcnt = 1;

	nm->nm_nlh = malloc(len);
	if (!nm->nm_nlh)
		goto errout;

	memset(nm->nm_nlh, 0, sizeof(struct nlmsghdr));

	nm->nm_protocol = -1;
	nm->nm_size = len;
	nm->nm_nlh->nlmsg_len = nlmsg_total_size(0);

	NL_DBG(2, "msg %p: Allocated new message, maxlen=%zu\n", nm, len);

	return nm;
errout:
	free(nm);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x48, %esi
callq 0x32c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4f38
jmp 0x4fad
movq -0x18(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0x33e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x4f64
jmp 0x4fad
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3240
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
xorl %edi, %edi
callq 0x5120
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl %ecx, (%rax)
jmp 0x4fa3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4fbe
movq -0x18(%rbp), %rdi
callq 0x3070
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_inherit
struct nl_msg *nlmsg_inherit(struct nlmsghdr *hdr)
{
	struct nl_msg *nm;

	nm = nlmsg_alloc();
	if (nm && hdr) {
		struct nlmsghdr *new = nm->nm_nlh;

		new->nlmsg_type = hdr->nlmsg_type;
		new->nlmsg_flags = hdr->nlmsg_flags;
		new->nlmsg_seq = hdr->nlmsg_seq;
		new->nlmsg_pid = hdr->nlmsg_pid;
	}

	return nm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x35e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x505b
cmpq $0x0, -0x8(%rbp)
je 0x505b
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movw 0x4(%rax), %cx
movq -0x18(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x8(%rbp), %rax
movw 0x6(%rax), %cx
movq -0x18(%rbp), %rax
movw %cx, 0x6(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_alloc_simple
struct nl_msg *nlmsg_alloc_simple(int nlmsgtype, int flags)
{
	struct nl_msg *msg;
	struct nlmsghdr nlh = {
		.nlmsg_type = nlmsgtype,
		.nlmsg_flags = flags,
	};

	msg = nlmsg_inherit(&nlh);
	if (msg)
		NL_DBG(2, "msg %p: Allocated new simple message\n", msg);

	return msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x4(%rbp), %eax
movw %ax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
movw %ax, -0x1a(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3060
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x50bb
jmp 0x50b7
jmp 0x50b9
jmp 0x50bb
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_convert
struct nl_msg *nlmsg_convert(struct nlmsghdr *hdr)
{
	struct nl_msg *nm;

	nm = __nlmsg_alloc(NLMSG_ALIGN(hdr->nlmsg_len));
	if (!nm)
		goto errout;

	memcpy(nm->nm_nlh, hdr, hdr->nlmsg_len);

	return nm;
errout:
	nlmsg_free(nm);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x4, %eax
subl $0x1, %eax
andl $-0x4, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x4f10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5181
jmp 0x51a4
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %edx
callq 0x3330
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x51b5
movq -0x18(%rbp), %rdi
callq 0x3640
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_free
void nlmsg_free(struct nl_msg *msg)
{
	if (!msg)
		return;

	msg->nm_refcnt--;
	NL_DBG(4, "Returned message reference %p, %d remaining\n",
	       msg, msg->nm_refcnt);

	if (msg->nm_refcnt < 0)
		BUG();

	if (msg->nm_refcnt <= 0) {
		free(msg->nm_nlh);
		free(msg);
		NL_DBG(2, "msg %p: Freed\n", msg);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x51d8
jmp 0x525a
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x40(%rax)
jmp 0x51e7
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jge 0x5236
jmp 0x51f3
movq 0x8dfe(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x4e3d(%rip), %rsi      # 0xa041
leaq 0x4e6e(%rip), %rdx      # 0xa079
movl $0x1ff, %ecx            # imm = 0x1FF
movb $0x0, %al
callq 0x32e0
leaq 0x4e3a(%rip), %rdi      # 0xa058
leaq 0x4e54(%rip), %rsi      # 0xa079
movl $0x1ff, %edx            # imm = 0x1FF
leaq 0x4e9d(%rip), %rcx      # 0xa0ce
callq 0x3210
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jg 0x525a
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3070
movq -0x8(%rbp), %rdi
callq 0x3070
jmp 0x5258
jmp 0x525a
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sabotage-linux[P]libnl-tiny/msg.c
// Function: nlmsg_reserve
void *nlmsg_reserve(struct nl_msg *n, size_t len, int pad)
{
	void *buf = n->nm_nlh;
	size_t nlmsg_len = n->nm_nlh->nlmsg_len;
	size_t tlen;

	tlen = pad ? ((len + (pad - 1)) & ~(pad - 1)) : len;

	if ((tlen + nlmsg_len) > n->nm_size)
		return NULL;

	buf += nlmsg_len;
	n->nm_nlh->nlmsg_len += tlen;

	if (tlen > len)
		memset(buf + len, 0, tlen - len);

	NL_DBG(2, "msg %p: Reserved %zu bytes, pad=%d, nlmsg_len=%d\n",
		  n, len, pad, n->nm_nlh->nlmsg_len);

	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %eax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x52b8
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
xorl $-0x1, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x52c0
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jbe 0x52e4
movq $0x0, -0x8(%rbp)
jmp 0x5330
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %ecx
addq %rdx, %rcx
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x5324
movq -0x28(%rbp), %rdi
addq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rdx
subq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x3240
jmp 0x5326
jmp 0x5328
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)