LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/repl.c
// Function: read_line
const char* read_line(uint32_t* length) {
  const int size = 1024;
  char* mem = (char*)malloc(size);
  if (fgets(mem, size, stdin) == NULL) {
    // TODO: handle error.
  }
  size_t len = strlen(mem);

  // FIXME: handle \r\n, this is temp.
  mem[len - 1] = '\0';
  if (length != NULL) *length = (uint32_t)(len - 1);

  return mem;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x400, 0x1c(%rsp)      # imm = 0x400
movl $0x400, %edi            # imm = 0x400
callq 0x22b0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0xd03c(%rip), %rax      # 0x32fd8
movq (%rax), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x2210
cmpq $0x0, %rax
jne 0x25fb1
jmp 0x25fb1
movq 0x10(%rsp), %rdi
callq 0x2130
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, 0x20(%rsp)
je 0x25fec
movq 0x8(%rsp), %rax
subq $0x1, %rax
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/repl.c
// Function: readLine
static void readLine(ByteBuffer* buff) {
  do {
    char c = (char)fgetc(stdin);
    if (c == EOF || c == '\n') break;

    byteBufferWrite(buff, (uint8_t)c);
  } while (true);

  byteBufferWrite(buff, '\0');
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0xccb8(%rip), %rax      # 0x32fd8
movq (%rax), %rdi
callq 0x21a0
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $-0x1, %eax
je 0x26340
movsbl 0xf(%rsp), %eax
cmpl $0xa, %eax
jne 0x26342
jmp 0x26359
movq 0x10(%rsp), %rdi
movzbl 0xf(%rsp), %esi
callq 0x265f0
movb $0x1, %al
testb $0x1, %al
jne 0x26319
jmp 0x26359
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x265f0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/repl.c
// Function: is_str_empty
static inline bool is_str_empty(const char* line) {
  ASSERT(line != NULL, OOPS);

  for (const char* c = line; *c != '\0'; c++) {
    if (!isspace(*c)) return false;
  }
  return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x263bb
movq 0xcc70(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
leaq 0x3dbe(%rip), %rsi      # 0x2a150
leaq 0x3ecb(%rip), %rdx      # 0x2a264
leaq 0x760d(%rip), %rcx      # 0x2d9ad
leaq 0x75fb(%rip), %r8       # 0x2d9a2
movl $0x32, %r9d
movb $0x0, %al
callq 0x2240
ud2
callq 0x2040
jmp 0x263bd
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x26409
callq 0x23a0
movq (%rax), %rax
movq (%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x263f9
movb $0x0, 0x17(%rsp)
jmp 0x2640e
jmp 0x263fb
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x263c6
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/utils.c
// Function: byteBufferClear
void byteBufferClear(ByteBuffer* buffer) {
  free(buffer->data);
  buffer->data = NULL;
  buffer->count = 0;
  buffer->capacity = 0;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x2030
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, 0xc(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/utils.c
// Function: byteBufferReserve
void byteBufferReserve(ByteBuffer* buffer, size_t size) {
  if (buffer->capacity < size) {
    int capacity = powerOf2Ceil((int)size);
    if (capacity < MIN_CAPACITY) capacity = MIN_CAPACITY;
    buffer->data = (uint8_t*)realloc(buffer->data, capacity * sizeof(uint8_t));
    buffer->capacity = capacity;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
cmpq 0x8(%rsp), %rax
jae 0x264f9
movq 0x8(%rsp), %rax
movl %eax, %edi
callq 0x26500
movl %eax, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jge 0x264cc
movl $0x8, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movslq 0x4(%rsp), %rsi
shlq $0x0, %rsi
callq 0x22e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/thirdparty/cwalk/cwalk.c
// Function: cwk_path_segment_joined_skip_invisible
static bool
cwk_path_segment_joined_skip_invisible(struct cwk_segment_joined* sj,
  bool absolute)
{
  while (cwk_path_segment_will_be_removed(sj, absolute)) {
    if (!cwk_path_get_next_segment_joined(sj)) {
      return false;
    }
  }

  return true;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x8(%rsp)
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x8(%rsp), %rdi
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x29070
testb $0x1, %al
jne 0x2707b
jmp 0x27092
movq 0x8(%rsp), %rdi
callq 0x27140
testb $0x1, %al
jne 0x27090
movb $0x0, 0x17(%rsp)
jmp 0x27097
jmp 0x27062
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/thirdparty/cwalk/cwalk.c
// Function: cwk_path_join
size_t cwk_path_join(const char* path_a, const char* path_b, char* buffer,
  size_t buffer_size)
{
  const char* paths[3];

  // This is simple. We will just create an array with the two paths which we
  // wish to join.
  paths[0] = path_a;
  paths[1] = path_b;
  paths[2] = NULL;

  // And then call the join and normalize function which will do the hard work
  // for us.
  return cwk_path_join_and_normalize_multiple(paths, buffer, buffer_size);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq %rsp, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x267d0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/thirdparty/argparse/argparse.c
// Function: argparse_init
int
argparse_init(struct argparse *self, struct argparse_option *options,
              const char *const *usages, int flags)
{
    memset(self, 0, sizeof(*self));
    self->options     = options;
    self->usages      = usages;
    self->flags       = flags;
    self->description = NULL;
    self->epilog      = NULL;
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x2180
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x20(%rax)
xorl %eax, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/thirdparty/argparse/argparse.c
// Function: argparse_options_check
static void
argparse_options_check(const struct argparse_option *options)
{
    for (; options->type != ARGPARSE_OPT_END; options++) {
        switch (options->type) {
        case ARGPARSE_OPT_END:
        case ARGPARSE_OPT_BOOLEAN:
        case ARGPARSE_OPT_BIT:
        case ARGPARSE_OPT_INTEGER:
        case ARGPARSE_OPT_FLOAT:
        case ARGPARSE_OPT_STRING:
        case ARGPARSE_OPT_GROUP:
            continue;
        default:
            fprintf(stderr, "wrong option type: %d", options->type);
            break;
        }
    }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0x0, (%rax)
je 0x2896b
movq (%rsp), %rax
movl (%rax), %eax
subl $0x6, %eax
ja 0x2893d
jmp 0x2893b
jmp 0x2895d
movq 0xa6b4(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
movq (%rsp), %rax
movl (%rax), %edx
leaq 0x520a(%rip), %rsi      # 0x2db5e
movb $0x0, %al
callq 0x2240
jmp 0x2895d
movq (%rsp), %rax
addq $0x38, %rax
movq %rax, (%rsp)
jmp 0x28925
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/thirdparty/argparse/argparse.c
// Function: argparse_short_opt
static int
argparse_short_opt(struct argparse *self, const struct argparse_option *options)
{
    for (; options->type != ARGPARSE_OPT_END; options++) {
        if (options->short_name == *self->optvalue) {
            self->optvalue = self->optvalue[1] ? self->optvalue + 1 : NULL;
            return argparse_getvalue(self, options, 0);
        }
    }
    return -2;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
je 0x28a0e
movq 0x10(%rsp), %rax
movsbl 0x4(%rax), %eax
movq 0x18(%rsp), %rcx
movq 0x48(%rcx), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x289f9
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x289cb
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x289d4
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x289d4
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x29340
movl %eax, 0x24(%rsp)
jmp 0x28a16
jmp 0x289fb
movq 0x10(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x10(%rsp)
jmp 0x2897e
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/thirdparty/argparse/argparse.c
// Function: argparse_long_opt
static int
argparse_long_opt(struct argparse *self, const struct argparse_option *options)
{
    for (; options->type != ARGPARSE_OPT_END; options++) {
        const char *rest;
        int opt_flags = 0;
        if (!options->long_name)
            continue;

        rest = prefix_skip(self->argv[0] + 2, options->long_name);
        if (!rest) {
            // negation disabled?
            if (options->flags & OPT_NONEG) {
                continue;
            }
            // only OPT_BOOLEAN/OPT_BIT supports negation
            if (options->type != ARGPARSE_OPT_BOOLEAN && options->type !=
                ARGPARSE_OPT_BIT) {
                continue;
            }

            if (prefix_cmp(self->argv[0] + 2, "no-")) {
                continue;
            }
            rest = prefix_skip(self->argv[0] + 2 + 3, options->long_name);
            if (!rest)
                continue;
            opt_flags |= OPT_UNSET;
        }
        if (*rest) {
            if (*rest != '=')
                continue;
            self->optvalue = rest + 1;
        }
        return argparse_getvalue(self, options, opt_flags | OPT_LONG);
    }
    return -2;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
je 0x28b6e
movl $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x28a55
jmp 0x28b5b
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
addq $0x2, %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x297b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x28b14
movq 0x10(%rsp), %rax
movl 0x30(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x28a99
jmp 0x28b5b
movq 0x10(%rsp), %rax
cmpl $0x2, (%rax)
je 0x28ab2
movq 0x10(%rsp), %rax
cmpl $0x3, (%rax)
je 0x28ab2
jmp 0x28b5b
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
addq $0x2, %rdi
leaq 0x51af(%rip), %rsi      # 0x2dc78
callq 0x29810
cmpl $0x0, %eax
je 0x28ad8
jmp 0x28b5b
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
addq $0x2, %rdi
addq $0x3, %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x297b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x28b09
jmp 0x28b5b
movl 0x4(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x28b3f
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x28b2d
jmp 0x28b5b
movq 0x8(%rsp), %rcx
addq $0x1, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %edx
orl $0x2, %edx
callq 0x29340
movl %eax, 0x24(%rsp)
jmp 0x28b76
movq 0x10(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x10(%rsp)
jmp 0x28a2e
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/thirdparty/argparse/argparse.c
// Function: argparse_error
static void
argparse_error(struct argparse *self, const struct argparse_option *opt,
               const char *reason, int flags)
{
    (void)self;
    if (flags & OPT_LONG) {
        fprintf(stderr, "error: option `--%s` %s\n", opt->long_name, reason);
    } else {
        fprintf(stderr, "error: option `-%c` %s\n", opt->short_name, reason);
    }
    exit(EXIT_FAILURE);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2977b
movq 0x989e(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rsp), %rcx
leaq 0x44d5(%rip), %rsi      # 0x2dc47
movb $0x0, %al
callq 0x2240
jmp 0x297a1
movq 0x9876(%rip), %rax      # 0x32ff8
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movsbl 0x4(%rax), %edx
movq 0x10(%rsp), %rcx
leaq 0x44c6(%rip), %rsi      # 0x2dc60
movb $0x0, %al
callq 0x2240
movl $0x1, %edi
callq 0x2360
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/atomlang[P]atomlang/cli/thirdparty/argparse/argparse.c
// Function: prefix_cmp
static int
prefix_cmp(const char *str, const char *prefix)
{
    for (;; str++, prefix++)
        if (!*prefix) {
            return 0;
        } else if (*str != *prefix) {
            return (unsigned char)*prefix - (unsigned char)*str;
        }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x2982e
movl $0x0, -0x4(%rsp)
jmp 0x2987c
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
movq -0x18(%rsp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x2985a
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
movq -0x10(%rsp), %rcx
movzbl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rsp)
jmp 0x2987c
jmp 0x2985c
jmp 0x2985e
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x2981a
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
  unsigned char       *c,
  unsigned long long  *clen,
  const unsigned char *m,
  unsigned long long  mlen,
  const unsigned char *ad,
  unsigned long long  adlen,
  const unsigned char *nsec,
  const unsigned char *npub,
  const unsigned char *k
  )
{
  unsigned long long cr;
  unsigned char tag[TAGBYTES];

  cr = mlen + adlen;
  if( (cr<mlen) && (cr<adlen) ) return -1;

  AEAD_ENC( k, npub, ad, adlen, m, mlen, c, clen, tag );

  Copy( c+*clen, tag, TAGBYTES );
  *clen += TAGBYTES;

  return 0;
}

// Assembly:
subq $0x78, %rsp
movq 0x90(%rsp), %rax
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x40(%rsp)
movq 0x50(%rsp), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x11ee
movq 0x38(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x11ee
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x1287
movq 0x90(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x58(%rsp), %r8
movq 0x50(%rsp), %r9
movq 0x68(%rsp), %r11
movq 0x60(%rsp), %r10
leaq 0x20(%rsp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x1090
movl $0x0, 0x1c(%rsp)
cmpl $0x10, 0x1c(%rsp)
jge 0x126e
movslq 0x1c(%rsp), %rax
movb 0x20(%rsp,%rax), %dl
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rcx
addq (%rcx), %rax
movslq 0x1c(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x123c
jmp 0x1270
movq 0x60(%rsp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
  unsigned char       *m,
  unsigned long long  *mlen,
  unsigned char       *nsec,
  const unsigned char *c,
  unsigned long long  clen,
  const unsigned char *ad,
  unsigned long long  adlen,
  const unsigned char *npub,
  const unsigned char *k
  )
{
  unsigned long long cr;
  unsigned char tag[TAGBYTES];

  cr = clen + adlen;
  if( (cr<clen) && (cr<adlen) ) return -1;

  clen -= TAGBYTES;
  if( clen % BLOCK_SIZE ) return -1;
  Copy( tag, c+clen, TAGBYTES );

  return AEAD_DEC( k, npub, ad, adlen, c, clen, tag, m, mlen );
}

// Assembly:
subq $0x78, %rsp
movq 0x90(%rsp), %rax
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x40(%rsp)
movq 0x48(%rsp), %rax
addq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x1304
movq 0x38(%rsp), %rax
cmpq 0x80(%rsp), %rax
jae 0x1304
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x13b6
movq 0x48(%rsp), %rax
subq $0x10, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
je 0x132e
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x13b6
jmp 0x1330
movl $0x0, 0x1c(%rsp)
cmpl $0x10, 0x1c(%rsp)
jge 0x1367
movq 0x50(%rsp), %rax
addq 0x48(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movb (%rax,%rcx), %cl
movslq 0x1c(%rsp), %rax
movb %cl, 0x20(%rsp,%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1338
jmp 0x1369
movq 0x90(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x80(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x48(%rsp), %r9
leaq 0x20(%rsp), %r11
movq 0x68(%rsp), %r10
movq 0x60(%rsp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x1080
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/ref/encrypt.c
// Function: crypto_mac_gen
int crypto_mac_gen(
  unsigned char       *c,     /* O    Tag                                 */
  unsigned long long  *clen,  /* O    Length of Tag                       */
  const unsigned char *m,     /* I    Message                             */
  unsigned long long  mlen,   /* I    Length of Message                   */
  const unsigned char *nsec,  /* I    Secret message number (not used)    */
  const unsigned char *npub,  /* I    Public message number (not used)    */
  const unsigned char *k      /* I    Secret key                          */
  )
{
  int ret;

  ret = MAC_GEN(  k, 
                  m, mlen, 
                  c, clen );

  return 0;
}

// Assembly:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0x1030
movl %eax, 0x4(%rsp)
xorl %eax, %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/ref/encrypt.c
// Function: crypto_mac_verif
int crypto_mac_verif(
  const unsigned char *c,     /* I    Tag to verified                     */
  unsigned long long  clen,   /* I    Length of Tag                       */
  const unsigned char *m,     /* I    Message                             */
  unsigned long long  mlen,   /* I    Length of Message                   */
  const unsigned char *nsec,  /* I    Secret message number (not used)    */  
  const unsigned char *npub,  /* I    Public message number (not used)    */
  const unsigned char *k      /* I    Secret key                          */
  )
{
  int ret;

  ret = MAC_VERIF( k, 
                   m, mlen, 
                   c, clen );

  if( ret != 0 ) return -1;

  return 0;
}

// Assembly:
subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0x1050
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x146a
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x1472
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/ref/minalpher.c
// Function: AEAD_DEC
int AEAD_DEC(
  const unsigned char     *_K,    /* I    Secret key              */
  const unsigned char     *_N,    /* I    Nonce                   */
  const unsigned char     *_AD,   /* I    Associate Data          */
  const unsigned long long _adlen,/* I    Length of Associate Data*/
  const unsigned char     *_C,    /* I    Ciphertext              */
  const unsigned long long _clen, /* I    Length of Ciphertext    */
  const unsigned char     *_tag,  /* I    Tag                     */

  unsigned char           *M_,    /* O    Message                 */
  unsigned long long      *mlen_  /* O    Length of Message       */
)
{
  int d, ret=0;
  unsigned char tagS[TAGBYTES];

  if( _clen < BLOCK_SIZE ) return -1;
  AEAD_TGEN( _K, _N, _AD, _adlen, _C, _clen, tagS );
  for( d=0; d<TAGBYTES; d++ ){
    if( _tag[d] != tagS[d] ) ret |= 1;
  }
  if( ret != 0 )  return -1;
  if(AEAD_MGEN( _K, _N, _C, _clen, M_, mlen_ ) < 0){
    return -1;
  }

  return 0;
}

// Assembly:
subq $0x68, %rsp
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq %r9, 0x30(%rsp)
movl $0x0, 0x28(%rsp)
cmpq $0x20, 0x30(%rsp)
jae 0x1dc1
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x1e80
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x1780
movl $0x0, 0x2c(%rsp)
cmpl $0x10, 0x2c(%rsp)
jge 0x1e32
movq 0x70(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movslq 0x2c(%rsp), %rcx
movzbl 0x10(%rsp,%rcx), %ecx
cmpl %ecx, %eax
je 0x1e23
movl 0x28(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x1e25
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1df5
cmpl $0x0, 0x28(%rsp)
je 0x1e43
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x1e80
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x78(%rsp), %r8
movq 0x80(%rsp), %r9
callq 0x1e90
cmpl $0x0, %eax
jge 0x1e78
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x1e80
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/ref/minalpher.c
// Function: MAC_VERIF
int MAC_VERIF(
  const unsigned char     *_K,    /* I    Secret key              */
  const unsigned char     *_M,    /* I    Message                 */
  unsigned long long      _mlen,  /* I    Length of Message       */

  const unsigned char     *_C,    /* I    Tag to be verified      */
  unsigned long long      _clen   /* I    Length of Tag           */
  )
{
  int result=0;
  unsigned long long d, len=0;
  unsigned char tag[TAGBYTES];

  result = MAC_GEN( _K, _M, _mlen, tag, &len );

  if( len != _clen ) result |= 1;
  for( d=0; d<len; d++ ){
    if( tag[d] != _C[d] ) result |= 1;
  }

  if( result != 0 ) return -1;
  return 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rsp, %rcx
leaq 0x10(%rsp), %r8
callq 0x1030
movl %eax, 0x24(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0x2815
movl 0x24(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x24(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x2862
movq 0x18(%rsp), %rax
movzbl (%rsp,%rax), %eax
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x2850
movl 0x24(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2852
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x281e
cmpl $0x0, 0x24(%rsp)
je 0x2873
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x287b
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/ref/minalpher.c
// Function: minalpher_P
static void minalpher_P(
  unsigned char   *_msg_,     /* I/O  Message                                 */
  unsigned char   _dir        /* I    Direction (0x00)Forward, (0x01)Backward */
)
{
  int r,rn;
  unsigned char dat[BLOCK_SIZE];

  Copy( dat, _msg_, BLOCK_SIZE );
  r = RNUM;

  while( r > 0 ){
    S( dat );
    T( dat );

    if( _dir == FORWARD ){
      rn = RNUM - r;
      M( dat );
      E( dat,rn );
    }else if( _dir == BACKWARD ){
      rn = r-1;
      E( dat,rn );
      M( dat );
    }
    r--;
  }

  S( dat );
  T( dat );

  Copy( _msg_, dat, BLOCK_SIZE );
}

// Assembly:
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x40(%rsp)
movb %al, 0x3f(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x20, 0xc(%rsp)
jge 0x2b12
movq 0x40(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb (%rax,%rcx), %cl
movslq 0xc(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2ae8
jmp 0x2b14
movl $0x11, 0x38(%rsp)
cmpl $0x0, 0x38(%rsp)
jle 0x2bab
leaq 0x10(%rsp), %rdi
callq 0x2e40
leaq 0x10(%rsp), %rdi
callq 0x2ec0
movzbl 0x3f(%rsp), %eax
cmpl $0x0, %eax
jne 0x2b6c
movl $0x11, %eax
subl 0x38(%rsp), %eax
movl %eax, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x3370
leaq 0x10(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x3550
jmp 0x2b9b
movzbl 0x3f(%rsp), %eax
cmpl $0x1, %eax
jne 0x2b99
movl 0x38(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x3550
leaq 0x10(%rsp), %rdi
callq 0x3370
jmp 0x2b9b
movl 0x38(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x2b1c
leaq 0x10(%rsp), %rdi
callq 0x2e40
leaq 0x10(%rsp), %rdi
callq 0x2ec0
movl $0x0, 0x8(%rsp)
cmpl $0x20, 0x8(%rsp)
jge 0x2bf1
movslq 0x8(%rsp), %rax
movb 0x10(%rsp,%rax), %dl
movq 0x40(%rsp), %rax
movslq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2bc7
jmp 0x2bf3
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/ref/minalpher.c
// Function: S
static void S( 
  unsigned char *_m_      /* I/O  Message     */
  )       
{
  int i;
  unsigned char t;

  /*--- SubNibbles ---*/
  for( i=0; i<BLOCK_SIZE; i++ ){
    t = _m_[i];
    _m_[i] = (s[t>>4]<<4) | s[t&0x0f];
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x20, -0xc(%rsp)
jge 0x2eb2
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xd(%rsp)
movzbl -0xd(%rsp), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0x1189(%rip), %rax      # 0x4000
movzbl (%rax,%rcx), %eax
shll $0x4, %eax
movzbl -0xd(%rsp), %ecx
andl $0xf, %ecx
movslq %ecx, %rdx
leaq 0x1170(%rip), %rcx      # 0x4000
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x2e4d
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/ref/minalpher.c
// Function: E
static void E( 
    unsigned char   *_m_,   /* I/O  Message         */
    int             _r      /* I    Round number    */
    )
{
  int i,j;
  unsigned char t;

  j=0;
  for( i=0; i<4; i++ ){
    t = ( ( ((unsigned char)i) ^ (((unsigned char)_r)&0x0f) )<<4 ) | ( ((unsigned char)i) ^ (((unsigned char)_r)&0x0f) );
    _m_[j+4] ^= 0x01 ^ t;
    _m_[j+5] ^= 0x23 ^ t;
    j+=8;
  }   
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0x10(%rsp)
cmpl $0x4, -0x10(%rsp)
jge 0x35fe
movl -0x10(%rsp), %eax
movzbl %al, %eax
movl -0xc(%rsp), %ecx
movzbl %cl, %ecx
andl $0xf, %ecx
xorl %ecx, %eax
shll $0x4, %eax
movl -0x10(%rsp), %ecx
movzbl %cl, %ecx
movl -0xc(%rsp), %edx
movzbl %dl, %edx
andl $0xf, %edx
xorl %edx, %ecx
orl %ecx, %eax
movb %al, -0x15(%rsp)
movzbl -0x15(%rsp), %esi
xorl $0x1, %esi
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movzbl -0x15(%rsp), %esi
xorl $0x23, %esi
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
addl $0x5, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x14(%rsp), %eax
addl $0x8, %eax
movl %eax, -0x14(%rsp)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x3569
retq
nop
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/huffman_codification_mpi.c
// Function: main
int main (int argc, char* argv[]) {

	MPI_Init (&argc, &argv);
    if (argc == 4) {
        huffman_compress(argv[INPUT_FILE], argv[OUTPUT_FILE], argv[CODIFICATION]);
    }
    else {
        printf("Bad arguments\n");
        printf("Usage huffman_serial_codification input_file ouput_file codification_file_name\n");
        MPI_Finalize();
	return 1;
    }

    MPI_Finalize();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x10d0
cmpl $0x4, -0x8(%rbp)
jne 0x1b48
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x1390
jmp 0x1b72
leaq 0x2511(%rip), %rdi      # 0x4060
movb $0x0, %al
callq 0x1040
leaq 0x2512(%rip), %rdi      # 0x406f
movb $0x0, %al
callq 0x1040
callq 0x1180
movl $0x1, -0x4(%rbp)
jmp 0x1b7e
callq 0x1180
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/acorn128/ref/encrypt.c
// Function: acorn128_initialization
void acorn128_initialization(const unsigned char *key, const unsigned char *iv, unsigned char *state)
{
        int i,j;
        unsigned char m[1536], ks, tem;

        //initialize the state to 0
        for (j = 0; j <= 292; j++) state[j] = 0;

        //set the value of m
        for (j = 0; j <= 127; j++) m[j]     = ( key[j/8] >> (j & 7) ) & 1;
        for (j = 0; j <= 127; j++) m[j+128] = ( iv[j/8]  >> (j & 7) ) & 1;
        m[256] = 1;
        for (j = 257; j <= 1535; j++) m[j]  = 0;

        //run the cipher for 1536 steps
        for (i = 0; i < 1536; i++)
        {
             Encrypt_StateUpdate128(state, m[i], &tem, &ks, 1, 1);
        }
}

// Assembly:
subq $0x648, %rsp            # imm = 0x648
movq %rdi, 0x640(%rsp)
movq %rsi, 0x638(%rsp)
movq %rdx, 0x630(%rsp)
movl $0x0, 0x628(%rsp)
cmpl $0x124, 0x628(%rsp) # imm = 0x124
jg 0x197e
movq 0x630(%rsp), %rax
movslq 0x628(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x628(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x628(%rsp)
jmp 0x194a
movl $0x0, 0x628(%rsp)
cmpl $0x7f, 0x628(%rsp)
jg 0x19ed
movq 0x640(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x628(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl 0x628(%rsp), %ecx
andl $0x7, %ecx
sarl %cl, %eax
andl $0x1, %eax
movb %al, %cl
movslq 0x628(%rsp), %rax
movb %cl, 0x20(%rsp,%rax)
movl 0x628(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x628(%rsp)
jmp 0x1989
movl $0x0, 0x628(%rsp)
cmpl $0x7f, 0x628(%rsp)
jg 0x1a62
movq 0x638(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x628(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl 0x628(%rsp), %ecx
andl $0x7, %ecx
sarl %cl, %eax
andl $0x1, %eax
movb %al, %cl
movl 0x628(%rsp), %eax
addl $0x80, %eax
cltq
movb %cl, 0x20(%rsp,%rax)
movl 0x628(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x628(%rsp)
jmp 0x19f8
movb $0x1, 0x120(%rsp)
movl $0x101, 0x628(%rsp) # imm = 0x101
cmpl $0x5ff, 0x628(%rsp) # imm = 0x5FF
jg 0x1aa2
movslq 0x628(%rsp), %rax
movb $0x0, 0x20(%rsp,%rax)
movl 0x628(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x628(%rsp)
jmp 0x1a75
movl $0x0, 0x62c(%rsp)
cmpl $0x600, 0x62c(%rsp) # imm = 0x600
jge 0x1afa
movq 0x630(%rsp), %rdi
movslq 0x62c(%rsp), %rax
leaq 0x1e(%rsp), %rdx
leaq 0x1f(%rsp), %rcx
movl $0x1, %r9d
movzbl 0x20(%rsp,%rax), %esi
movl %r9d, %r8d
callq 0x1030
movl 0x62c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x62c(%rsp)
jmp 0x1aad
addq $0x648, %rsp            # imm = 0x648
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/acorn128/ref/encrypt.c
// Function: acorn128_tag_generation
void acorn128_tag_generation(unsigned long long msglen, unsigned long long adlen, unsigned char maclen, unsigned char *mac, unsigned char *state)
{
    int i;
    unsigned char plaintextbyte  = 0;
    unsigned char ciphertextbyte = 0;
    unsigned char ksbyte = 0;

    for (i = 0; i < 512/8; i++)
    {
        acorn128_enc_onebyte(state, plaintextbyte, &ciphertextbyte, &ksbyte, 0xff, 0xff);
        if ( i >= (512/8 - 16) ) {mac[i-(512/8-16)] = ksbyte; }
    }
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movb $0x0, 0xb(%rsp)
movb $0x0, 0xa(%rsp)
movb $0x0, 0x9(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x40, 0xc(%rsp)
jge 0x1b9a
movq 0x10(%rsp), %rdi
leaq 0xa(%rsp), %rdx
leaq 0x9(%rsp), %rcx
movl $0xff, %r9d
movzbl 0xb(%rsp), %esi
movl %r9d, %r8d
callq 0x10d0
cmpl $0x30, 0xc(%rsp)
jl 0x1b8b
movb 0x9(%rsp), %dl
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
subl $0x30, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x1b8d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1b45
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aimerneige[P]st/x.c
// Function: xsetpointermotion
void
xsetpointermotion(int set)
{
	if (!set && !xw.pointerisvisible)
		return;
	MODBIT(xw.attrs.event_mask, set, PointerMotionMask);
	XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, &xw.attrs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xe6cc
cmpl $0x0, 0x12d68(%rip)     # 0x21430
jne 0xe6cc
jmp 0xe71b
cmpl $0x0, -0x4(%rbp)
je 0xe6e6
movq 0x12d1f(%rip), %rax     # 0x213f8
orq $0x40, %rax
movq %rax, 0x12d14(%rip)     # 0x213f8
jmp 0xe6f8
movq 0x12d0b(%rip), %rax     # 0x213f8
andq $-0x41, %rax
movq %rax, 0x12d00(%rip)     # 0x213f8
movq 0x12c39(%rip), %rdi     # 0x21338
movq 0x12c42(%rip), %rsi     # 0x21348
movl $0x800, %edx            # imm = 0x800
leaq 0x12c26(%rip), %rcx     # 0x21338
addq $0x78, %rcx
callq 0x5950
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aimerneige[P]st/x.c
// Function: bmotion
void
bmotion(XEvent *e)
{
	if (!xw.pointerisvisible) {
		XDefineCursor(xw.dpy, xw.win, xw.vpointer);
		xw.pointerisvisible = 1;
		if (!IS_SET(MODE_MOUSEMANY))
			xsetpointermotion(0);
	}

	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
		mousereport(e);
		return;
	}

	mousesel(e, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x103fd(%rip)     # 0x21430
jne 0x11072
movq 0x102fc(%rip), %rdi     # 0x21338
movq 0x10305(%rip), %rsi     # 0x21348
movq 0x103d6(%rip), %rdx     # 0x21420
callq 0x5750
movl $0x1, 0x103d7(%rip)     # 0x21430
movl 0x10419(%rip), %eax     # 0x21478
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
jne 0x11070
xorl %edi, %edi
callq 0xe6b0
jmp 0x11072
movl 0x10400(%rip), %eax     # 0x21478
andl $0xc018, %eax           # imm = 0xC018
cmpl $0x0, %eax
je 0x1109f
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
andl 0x9e51(%rip), %eax      # 0x1aee0
cmpl $0x0, %eax
jne 0x1109f
movq -0x8(%rbp), %rdi
callq 0x11c90
jmp 0x110aa
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x12180
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/developer_cmds/what/what.c
// Function: main
int
main(argc, argv)
	int argc;
	char **argv;
{
	if (!*++argv) 
		search();
	else do {
		if (!freopen(*argv, "r", stdin)) {
			perror(*argv);
			exit(1);
		}
		printf("%s\n", *argv);
		search();
	} while(*++argv);
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x11c3
callq 0x1240
jmp 0x1230
jmp 0x11c5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq 0x2e0d(%rip), %rax      # 0x3fe0
movq (%rax), %rdx
leaq 0xe27(%rip), %rsi       # 0x2004
callq 0x1050
cmpq $0x0, %rax
jne 0x11fe
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1070
movl $0x1, %edi
callq 0x1080
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xdfa(%rip), %rdi       # 0x2006
movb $0x0, %al
callq 0x1040
callq 0x1240
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x11c5
jmp 0x1230
xorl %edi, %edi
callq 0x1080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/developer_cmds/what/what.c
// Function: search
void
search()
{
	int c;

	while ((c = getchar()) != EOF) {
loop:		if (c != '@')
			continue;
		if ((c = getchar()) != '(')
			goto loop;
		if ((c = getchar()) != '#')
			goto loop;
		if ((c = getchar()) != ')')
			goto loop;
		putchar('\t');
		while ((c = getchar()) != EOF && c && c != '"' &&
		    c != '>' && c != '\n')
			putchar(c);
		putchar('\n');
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1060
movl %eax, -0x4(%rbp)
cmpl $-0x1, %eax
je 0x12fb
jmp 0x125b
cmpl $0x40, -0x4(%rbp)
je 0x1263
jmp 0x1248
callq 0x1060
movl %eax, -0x4(%rbp)
cmpl $0x28, %eax
je 0x1272
jmp 0x125b
callq 0x1060
movl %eax, -0x4(%rbp)
cmpl $0x23, %eax
je 0x1281
jmp 0x125b
callq 0x1060
movl %eax, -0x4(%rbp)
cmpl $0x29, %eax
je 0x1290
jmp 0x125b
movl $0x9, %edi
callq 0x1030
callq 0x1060
movl %eax, %ecx
movl %ecx, -0x4(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x5(%rbp)
je 0x12d9
xorl %eax, %eax
cmpl $0x0, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x12d9
xorl %eax, %eax
cmpl $0x22, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x12d9
xorl %eax, %eax
cmpl $0x3e, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x12d9
cmpl $0xa, -0x4(%rbp)
setne %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x12e2
jmp 0x12ec
movl -0x4(%rbp), %edi
callq 0x1030
jmp 0x129a
movl $0xa, %edi
callq 0x1030
jmp 0x1248
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tools/configctl.c
// Function: main
int main(int argc, char * argv[])
{
	int o;
	int list = 0;
	int verbose = 0;
	int write = 0;
	char const * filename = NULL;

	while((o = getopt(argc, argv, "af:qvw")) != -1)
		switch(o)
		{
			case 'a':
				list = 1;
				break;
			case 'f':
				filename = optarg;
				break;
			case 'q':
				verbose = -1;
				break;
			case 'v':
				verbose = 1;
				break;
			case 'w':
				write = 1;
				break;
			default:
				return _usage();
		}
	if(list)
	{
		if(verbose != 0 || write != 0 || filename == NULL
				|| optind != argc)
			return _usage();
		return _configctl_list(filename) ? 0 : 2;
	}
	if(filename == NULL || optind == argc)
		return _usage();
	return (_configctl(verbose, write, filename, argc - optind,
				&argv[optind]) == 0) ? 0 : 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xe1f(%rip), %rdx       # 0x2060
callq 0x10d0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x12b9
movl -0x14(%rbp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x16, %eax
ja 0x12a7
movq -0x30(%rbp), %rax
leaq 0xd9a(%rip), %rcx       # 0x2004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x18(%rbp)
jmp 0x12b4
movq 0x2d55(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x12b4
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x12b4
movl $0x1, -0x1c(%rbp)
jmp 0x12b4
movl $0x1, -0x20(%rbp)
jmp 0x12b4
callq 0x1380
movl %eax, -0x4(%rbp)
jmp 0x1368
jmp 0x1233
cmpl $0x0, -0x18(%rbp)
je 0x1307
cmpl $0x0, -0x1c(%rbp)
jne 0x12e0
cmpl $0x0, -0x20(%rbp)
jne 0x12e0
cmpq $0x0, -0x28(%rbp)
je 0x12e0
movq 0x2cf7(%rip), %rax      # 0x3fd0
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
je 0x12ea
callq 0x1380
movl %eax, -0x4(%rbp)
jmp 0x1368
movq -0x28(%rbp), %rdi
callq 0x13b0
movl %eax, %edx
movl $0x2, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1368
cmpq $0x0, -0x28(%rbp)
je 0x131c
movq 0x2cbb(%rip), %rax      # 0x3fd0
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x1326
callq 0x1380
movl %eax, -0x4(%rbp)
jmp 0x1368
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x8(%rbp), %ecx
movq 0x2c96(%rip), %rax      # 0x3fd0
subl (%rax), %ecx
movq -0x10(%rbp), %r8
movq 0x2c89(%rip), %rax      # 0x3fd0
movslq (%rax), %rax
shlq $0x3, %rax
addq %rax, %r8
callq 0x1450
movl %eax, %edx
movl $0x2, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
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/DeforaOS[P]libSystem/tools/configctl.c
// Function: configctl_list
static int _configctl_list(char const * filename)
{
	Config * config;

	if((config = config_new()) == NULL)
		return -_configctl_error(PROGNAME, 1);
	if(config_load(config, filename) != 0)
	{
		config_delete(config);
		return -_configctl_error(PROGNAME, 1);
	}
	config_foreach(config, _list_foreach, NULL);
	config_delete(config);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x10e0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x13e7
leaq 0xdb4(%rip), %rdi       # 0x2186
movl $0x1, %esi
callq 0x15f0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1442
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1040
cmpl $0x0, %eax
je 0x141e
movq -0x18(%rbp), %rdi
callq 0x1090
leaq 0xd7d(%rip), %rdi       # 0x2186
movl $0x1, %esi
callq 0x15f0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1442
movq -0x18(%rbp), %rdi
leaq 0x1f7(%rip), %rsi       # 0x1620
xorl %eax, %eax
movl %eax, %edx
callq 0x1080
movq -0x18(%rbp), %rdi
callq 0x1090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tools/configctl.c
// Function: configctl
static int _configctl(int verbose, int write, char const * filename, int argc,
		char * argv[])
{
	int ret = 0;
	Config * config;
	int i;
	char * section;
	char * key;
	char * value = NULL;

	if((config = config_new()) == NULL)
		return -_configctl_error(PROGNAME, 1);
	if(config_load(config, filename) != 0)
	{
		config_delete(config);
		return -_configctl_error(PROGNAME, 1);
	}
	for(i = 0; i < argc; i++)
	{
		section = argv[i];
		if((key = strchr(section, '.')) == NULL)
		{
			key = section;
			section = NULL;
		}
		else
			*(key++) = '\0';
		if(write && (value = strchr(key, '=')) != NULL)
			*(value++) = '\0';
		ret |= _configctl_do(config, verbose, section, key, value);
	}
	if(ret == 0 && write && config_save(config, filename) != 0)
		ret = -_configctl_error(PROGNAME, 1);
	config_delete(config);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x58(%rbp)
callq 0x10e0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x14a6
leaq 0xcf8(%rip), %rdi       # 0x2186
movl $0x1, %esi
callq 0x15f0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x15e2
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1040
cmpl $0x0, %eax
je 0x14e0
movq -0x38(%rbp), %rdi
callq 0x1090
leaq 0xcbe(%rip), %rdi       # 0x2186
movl $0x1, %esi
callq 0x15f0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x15e2
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x159b
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movl $0x2e, %esi
callq 0x1050
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
jne 0x152d
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
jmp 0x153f
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x50(%rbp)
movb $0x0, (%rax)
cmpl $0x0, -0xc(%rbp)
je 0x156f
movq -0x50(%rbp), %rdi
movl $0x3d, %esi
callq 0x1050
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x156f
movq -0x58(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x58(%rbp)
movb $0x0, (%rax)
movq -0x38(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %r8
callq 0x17c0
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x14e7
cmpl $0x0, -0x2c(%rbp)
jne 0x15d3
cmpl $0x0, -0xc(%rbp)
je 0x15d3
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10b0
cmpl $0x0, %eax
je 0x15d3
leaq 0xbc6(%rip), %rdi       # 0x2186
movl $0x1, %esi
callq 0x15f0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1090
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tools/configctl.c
// Function: configctl_print
static void _configctl_print(int verbose, char const * section,
		char const * variable, char const * value)
{
	if(verbose < 0)
		return;
	printf("%s%s%s%s%s\n", (verbose > 0 && section != NULL) ? section : "",
			(verbose > 0 && section != NULL && section[0] != '\0')
			? "." : "",
			(verbose > 0) ? variable : "",
			(verbose > 0) ? "=" : "",
			(value != NULL) ? value : "");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x16c2
jmp 0x17b2
cmpl $0x0, -0x4(%rbp)
jle 0x16d9
cmpq $0x0, -0x10(%rbp)
je 0x16d9
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x16e6
leaq 0xabb(%rip), %rax       # 0x219b
movq %rax, -0x28(%rbp)
jmp 0x16e6
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x4(%rbp)
movb %al, -0x29(%rbp)
jle 0x1715
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
je 0x1715
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %dl
leaq 0xa7c(%rip), %rax       # 0x219b
leaq 0xa76(%rip), %rcx       # 0x219c
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x1741
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x174e
leaq 0xa53(%rip), %rax       # 0x219b
movq %rax, -0x48(%rbp)
jmp 0x174e
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x4(%rbp), %edx
leaq 0xa3b(%rip), %rax       # 0x219b
leaq 0xa37(%rip), %rcx       # 0x219e
cmpl $0x0, %edx
cmovgq %rcx, %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1783
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x1790
leaq 0xa11(%rip), %rax       # 0x219b
movq %rax, -0x60(%rbp)
jmp 0x1790
movq -0x50(%rbp), %r8
movq -0x58(%rbp), %rcx
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
movq -0x60(%rbp), %r9
leaq 0x9e5(%rip), %rdi       # 0x2190
movb $0x0, %al
callq 0x1060
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)