LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: finish_attribute_value
static void finish_attribute_value(GumboParser* parser) {
  GumboTagState* tag_state = &parser->_tokenizer_state->_tag_state;
  if (tag_state->_drop_next_attr_value) {
    // Duplicate attribute name detected in an earlier state, so we have to
    // ignore the value.
    tag_state->_drop_next_attr_value = false;
    reinitialize_tag_buffer(parser);
    return;
  }

  GumboAttribute* attr =
      tag_state->_attributes.data[tag_state->_attributes.length - 1];
  gumbo_free((void*) attr->value);
  copy_over_tag_buffer(parser, &attr->value);
  copy_over_original_tag_text(
      parser, &attr->original_value, &attr->value_start, &attr->value_end);
  reinitialize_tag_buffer(parser);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x68, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x50(%rax)
je 0x17aa9
movq -0x10(%rbp), %rax
movb $0x0, 0x50(%rax)
movq -0x8(%rbp), %rdi
callq 0x175a0
jmp 0x17b10
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x48(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x17d80
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
callq 0x17940
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
movq -0x18(%rbp), %rdx
addq $0x68, %rdx
movq -0x18(%rbp), %rcx
addq $0x80, %rcx
callq 0x17990
movq -0x8(%rbp), %rdi
callq 0x175a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: emit_comment
static StateResult emit_comment(GumboParser* parser, GumboToken* output) {
  output->type = GUMBO_TOKEN_COMMENT;
  finish_temporary_buffer(parser, &output->v.text);
  finish_token(parser, output);
  return RETURN_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x3, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x17b70
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x120e0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: emit_doctype
static void emit_doctype(GumboParser* parser, GumboToken* output) {
  output->type = GUMBO_TOKEN_DOCTYPE;
  output->v.doc_type = parser->_tokenizer_state->_doc_type_state;
  finish_token(parser, output);
  doc_type_state_init(parser);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq 0xc8(%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0xd0(%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0xd8(%rcx), %rdx
movq %rdx, 0x40(%rax)
movq 0xe0(%rcx), %rcx
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x120e0
movq -0x8(%rbp), %rdi
callq 0x11aa0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: finish_doctype_public_id
static void finish_doctype_public_id(GumboParser* parser) {
  GumboTokenDocType* doc_type_state =
      &parser->_tokenizer_state->_doc_type_state;
  gumbo_free((void*) doc_type_state->public_identifier);
  finish_temporary_buffer(parser, &doc_type_state->public_identifier);
  doc_type_state->has_public_identifier = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0xc8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x17d80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x17b70
movq -0x10(%rbp), %rax
movb $0x1, 0x19(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/tokenizer.c
// Function: finish_doctype_system_id
static void finish_doctype_system_id(GumboParser* parser) {
  GumboTokenDocType* doc_type_state =
      &parser->_tokenizer_state->_doc_type_state;
  gumbo_free((void*) doc_type_state->system_identifier);
  finish_temporary_buffer(parser, &doc_type_state->system_identifier);
  doc_type_state->has_system_identifier = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0xc8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x17d80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x17b70
movq -0x10(%rbp), %rax
movb $0x1, 0x1a(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/util.c
// Function: gumbo_alloc
void* gumbo_alloc(size_t size) {
  void* ptr = malloc(size);
  if (unlikely(ptr == NULL)) {
    perror(__func__);
    abort();
  }
  return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x17d21
leaq 0x1f5e7(%rip), %rdi     # 0x372fe
callq 0x4250
callq 0x4050
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/util.c
// Function: gumbo_realloc
void* gumbo_realloc(void* ptr, size_t size) {
  ptr = realloc(ptr, size);
  if (unlikely(ptr == NULL)) {
    perror(__func__);
    abort();
  }
  return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4210
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x17d69
leaq 0x1f5ab(%rip), %rdi     # 0x3730a
callq 0x4250
callq 0x4050
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/util.c
// Function: gumbo_strdup
char* gumbo_strdup(const char* str) {
  const size_t size = strlen(str) + 1;
  // The strdup(3) function isn't available in strict "-std=c99" mode
  // (it's part of POSIX, not C99), so use malloc(3) and memcpy(3)
  // instead:
  char* buffer = gumbo_alloc(size);
  return memcpy(buffer, str, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40b0
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17cf0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x41a0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/char_ref.c
// Function: gumbo_consume_char_ref
bool gumbo_consume_char_ref (
  struct GumboParser* parser,
  struct GumboUtf8Iterator* input,
  int additional_allowed_char,
  bool is_in_attribute,
  OneOrTwoCodepoints* output
) {
  utf8iterator_mark(input);
  utf8iterator_next(input);
  int c = utf8iterator_current(input);
  output->first = kGumboNoChar;
  output->second = kGumboNoChar;
  if (c == additional_allowed_char) {
    utf8iterator_reset(input);
    output->first = kGumboNoChar;
    return true;
  }
  switch (utf8iterator_current(input)) {
    case '\t':
    case '\n':
    case '\f':
    case ' ':
    case '<':
    case '&':
    case -1:
      utf8iterator_reset(input);
      return true;
    case '#':
      return consume_numeric_ref(parser, input, &output->first);
    default:
      return consume_named_ref(parser, input, is_in_attribute, output);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6790
movq -0x18(%rbp), %rdi
callq 0x6500
movq -0x18(%rbp), %rdi
callq 0x17f10
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x17e65
movq -0x18(%rbp), %rdi
callq 0x67d0
movq -0x28(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movb $0x1, -0x1(%rbp)
jmp 0x17efe
movq -0x18(%rbp), %rdi
callq 0x17f10
movl %eax, %ecx
movl %ecx, -0x30(%rbp)
subl $-0x1, %eax
je 0x17eb9
jmp 0x17e7a
movl -0x30(%rbp), %eax
addl $-0x9, %eax
subl $0x2, %eax
jb 0x17eb9
jmp 0x17e87
movl -0x30(%rbp), %eax
subl $0xc, %eax
je 0x17eb9
jmp 0x17e91
movl -0x30(%rbp), %eax
subl $0x20, %eax
je 0x17eb9
jmp 0x17e9b
movl -0x30(%rbp), %eax
subl $0x23, %eax
je 0x17ec8
jmp 0x17ea5
movl -0x30(%rbp), %eax
subl $0x26, %eax
je 0x17eb9
jmp 0x17eaf
movl -0x30(%rbp), %eax
subl $0x3c, %eax
jne 0x17ee0
jmp 0x17eb9
movq -0x18(%rbp), %rdi
callq 0x67d0
movb $0x1, -0x1(%rbp)
jmp 0x17efe
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x17f30
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x17efe
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x1d(%rbp), %al
movq -0x28(%rbp), %rcx
andb $0x1, %al
movzbl %al, %edx
callq 0x18110
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/char_ref.c
// Function: parse_digit
static int CONST_FN parse_digit(int c, bool allow_hex) {
  if (c >= '0' && c <= '9') {
    return c - '0';
  }
  if (allow_hex && c >= 'a' && c <= 'f') {
    return c - 'a' + 10;
  }
  if (allow_hex && c >= 'A' && c <= 'F') {
    return c - 'A' + 10;
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movl %edi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
cmpl $0x30, -0x8(%rbp)
jl 0x2e2f6
cmpl $0x39, -0x8(%rbp)
jg 0x2e2f6
movl -0x8(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x2e33d
testb $0x1, -0x9(%rbp)
je 0x2e316
cmpl $0x61, -0x8(%rbp)
jl 0x2e316
cmpl $0x66, -0x8(%rbp)
jg 0x2e316
movl -0x8(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x2e33d
testb $0x1, -0x9(%rbp)
je 0x2e336
cmpl $0x41, -0x8(%rbp)
jl 0x2e336
cmpl $0x46, -0x8(%rbp)
jg 0x2e336
movl -0x8(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x2e33d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/char_ref.c
// Function: add_no_digit_error
static void add_no_digit_error (
  struct GumboParser* parser,
  Utf8Iterator* input
) {
  GumboError* error = gumbo_add_error(parser);
  if (!error) {
    return;
  }
  utf8iterator_fill_error_at_mark(input, error);
  error->type = GUMBO_ERR_NUMERIC_CHAR_REF_NO_DIGITS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5210
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2e376
jmp 0x2e38d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6820
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/char_ref.c
// Function: add_codepoint_error
static void add_codepoint_error (
  struct GumboParser* parser,
  Utf8Iterator* input,
  GumboErrorType type,
  int codepoint
) {
  GumboError* error = gumbo_add_error(parser);
  if (!error) {
    return;
  }
  utf8iterator_fill_error_at_mark(input, error);
  error->type = type;
  error->v.codepoint = codepoint;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5210
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2e3cc
jmp 0x2e3ec
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6820
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/char_ref.c
// Function: add_named_reference_error
static void add_named_reference_error (
  struct GumboParser* parser,
  Utf8Iterator* input,
  GumboErrorType type,
  GumboStringPiece text
) {
  GumboError* error = gumbo_add_error(parser);
  if (!error) {
    return;
  }
  utf8iterator_fill_error_at_mark(input, error);
  error->type = type;
  error->v.text = text;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5210
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2e4d1
jmp 0x2e4fb
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6820
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/char_ref.c
// Function: maybe_add_invalid_named_reference
static bool maybe_add_invalid_named_reference (
  struct GumboParser* parser,
  Utf8Iterator* input
) {
  // The iterator will always be reset in this code path, so we don't need to
  // worry about consuming characters.
  const char* start = utf8iterator_get_char_pointer(input);
  unsigned int c = utf8iterator_current(input);
  while (c < 0x80 && ascii_isalnum(c)) {
    utf8iterator_next(input);
    c = utf8iterator_current(input);
  }
  if (c == ';') {
    GumboStringPiece bad_ref;
    bad_ref.data = start;
    bad_ref.length = utf8iterator_get_char_pointer(input) - start;
    add_named_reference_error (
      parser,
      input,
      GUMBO_ERR_NAMED_CHAR_REF_INVALID,
      bad_ref
    );
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2e430
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17f10
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x80, -0x24(%rbp)
movb %al, -0x39(%rbp)
jae 0x2e55a
movl -0x24(%rbp), %eax
movl $0x32, %esi
movzbl %al, %edi
callq 0x2e470
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x2e563
jmp 0x2e57a
movq -0x18(%rbp), %rdi
callq 0x6500
movq -0x18(%rbp), %rdi
callq 0x17f10
movl %eax, -0x24(%rbp)
jmp 0x2e539
cmpl $0x3b, -0x24(%rbp)
jne 0x2e5bc
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2e430
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x7, %edx
callq 0x2e4a0
movb $0x0, -0x1(%rbp)
jmp 0x2e5c0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/craigbarnes[P]lua-gumbo/lib/foreign_attrs.c
// Function: gumbo_get_foreign_attr_replacement
const ForeignAttrReplacement *
gumbo_get_foreign_attr_replacement (register const char *str, register size_t len)
{
  static const unsigned char lengthtable[] =
    {
       5, 11,  9, 13, 10, 10, 10, 11, 10,  8,  8
    };
  static const ForeignAttrReplacement wordlist[] =
    {
      {"xmlns", "xmlns", GUMBO_ATTR_NAMESPACE_XMLNS},
      {"xmlns:xlink", "xlink", GUMBO_ATTR_NAMESPACE_XMLNS},
      {"xml:space", "space", GUMBO_ATTR_NAMESPACE_XML},
      {"xlink:actuate", "actuate", GUMBO_ATTR_NAMESPACE_XLINK},
      {"xlink:type", "type", GUMBO_ATTR_NAMESPACE_XLINK},
      {"xlink:href", "href", GUMBO_ATTR_NAMESPACE_XLINK},
      {"xlink:role", "role", GUMBO_ATTR_NAMESPACE_XLINK},
      {"xlink:title", "title", GUMBO_ATTR_NAMESPACE_XLINK},
      {"xlink:show", "show", GUMBO_ATTR_NAMESPACE_XLINK},
      {"xml:lang", "lang", GUMBO_ATTR_NAMESPACE_XML},
      {"xml:base", "base", GUMBO_ATTR_NAMESPACE_XML}
    };

  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
    {
      register unsigned int key = hash (str, len);

      if (key <= MAX_HASH_VALUE)
        if (len == lengthtable[key])
          {
            register const char *s = wordlist[key].from;

            if (s && *str == *s && !memcmp (str + 1, s + 1, len - 1))
              return &wordlist[key];
          }
    }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0xd, -0x18(%rbp)
ja 0x2e69d
cmpq $0x5, -0x18(%rbp)
jb 0x2e69d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2e6b0
movl %eax, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
ja 0x2e69b
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
leaq 0x3ecf0(%rip), %rcx     # 0x6d310
movzbl (%rcx,%rdx), %ecx
cmpq %rcx, %rax
jne 0x2e699
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x44e4b(%rip), %rax     # 0x73480
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2e697
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x2e697
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
callq 0x4150
cmpl $0x0, %eax
jne 0x2e697
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x44df6(%rip), %rax     # 0x73480
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x2e6a5
jmp 0x2e699
jmp 0x2e69b
jmp 0x2e69d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/mi_ln.c
// Function: main
int main (int argc, char **argv) {
	if (argc != 4) {
		printf("Número de parametros incorrectos\n");
		return -1;
	}
	//Montamos el disco
	bmount(argv[1]);

	if(mi_link (argv[2],argv[3]) == 0) printf("Enlace creado correctamente\n");
	else printf("Error: No se ha podido llevar a cabo mi_ln\n");

	bumount();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0x5e83
leaq 0x6e6(%rip), %rdi       # 0x6559
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5ed6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1280
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x50c0
cmpl $0x0, %eax
jne 0x5eba
leaq 0x6cb(%rip), %rdi       # 0x657c
movb $0x0, %al
callq 0x1090
jmp 0x5ec8
leaq 0x6d8(%rip), %rdi       # 0x6599
movb $0x0, %al
callq 0x1090
movb $0x0, %al
callq 0x12e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Babkock[P]st/st.c
// Function: newterm
void
newterm(const Arg* a)
{
	int res;
	switch (fork()) {
		case -1:
			die("fork failed: %s\n", strerror(errno));
			break;
		case 0:
			switch (fork()) {
				case -1:
					die("fork failed: %s\n", strerror(errno));
					break;
				case 0:
					chdir_by_pid(pid);
					execlp("/proc/self/exe", argv0, NULL);
					exit(1);
					break;
				default:
					exit(0);
			}
		default:
			wait(NULL);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x6870
movl %eax, %ecx
movl %ecx, -0x10(%rbp)
subl $-0x1, %eax
je 0x8f89
jmp 0x8f7d
movl -0x10(%rbp), %eax
testl %eax, %eax
je 0x8fa8
jmp 0x901b
callq 0x6600
movl (%rax), %edi
callq 0x64b0
movq %rax, %rsi
leaq 0xc91c(%rip), %rdi      # 0x158bb
movb $0x0, %al
callq 0x6b40
jmp 0x9024
callq 0x6870
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
subl $-0x1, %eax
je 0x8fc2
jmp 0x8fb9
movl -0x14(%rbp), %eax
testl %eax, %eax
je 0x8fe1
jmp 0x9012
callq 0x6600
movl (%rax), %edi
callq 0x64b0
movq %rax, %rsi
leaq 0xc8e3(%rip), %rdi      # 0x158bb
movb $0x0, %al
callq 0x6b40
jmp 0x9019
movl 0x18095(%rip), %edi     # 0x2107c
callq 0x9030
leaq 0x1a63d(%rip), %rax     # 0x23630
movq (%rax), %rsi
leaq 0xc92a(%rip), %rdi      # 0x15927
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x6250
movl $0x1, %edi
callq 0x61b0
xorl %edi, %edi
callq 0x61b0
jmp 0x901b
xorl %eax, %eax
movl %eax, %edi
callq 0x6110
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Babkock[P]st/x.c
// Function: xbell
void
xbell(void)
{
	if (!(IS_SET(MODE_FOCUSED)))
		xseturgency(1);
	if (bellvolume)
		XkbBell(xw.dpy, xw.win, bellvolume, (Atom)NULL);
	if (vbelltimeout)
		vbellbegin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x13fe6(%rip), %eax     # 0x23600
andl $0x2, %eax
cmpl $0x0, %eax
jne 0xf62c
movl $0x1, %edi
callq 0xf670
cmpl $0x0, 0xb979(%rip)      # 0x1afac
je 0xf652
movq 0x13e9c(%rip), %rdi     # 0x234d8
movq 0x13ea5(%rip), %rsi     # 0x234e8
movl 0xb963(%rip), %edx      # 0x1afac
xorl %eax, %eax
movl %eax, %ecx
callq 0x6920
cmpl $0x0, 0xbc3b(%rip)      # 0x1b294
je 0xf660
callq 0x11170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Babkock[P]st/x.c
// Function: vbellbegin
static void
vbellbegin() {
	clock_gettime(CLOCK_MONOTONIC, &lastvbell);
	if (vbellset)
		return;
	vbellset = 1;
	redraw();
	XFlush(xw.dpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %edi
leaq 0x12530(%rip), %rsi     # 0x236b0
callq 0x6150
cmpl $0x0, 0x1248c(%rip)     # 0x23618
je 0x11190
jmp 0x111ab
movl $0x1, 0x1247e(%rip)     # 0x23618
callq 0x9ae0
movq 0x12332(%rip), %rdi     # 0x234d8
callq 0x6610
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/smilingthax[P]libfontembed/font_get.c
// Function: parse_tag
static unsigned int parse_tag(const char *name) // {{{
{
  assert(name);

  if (strlen(name)!=4) {
    fprintf(stderr,"Error: Tag name must have exactly 4 letters");
    return 0;
  }

  return OTF_TAG(name[0],name[1],name[2],name[3]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1545
jmp 0x1564
leaq 0x3b73(%rip), %rdi      # 0x50bf
leaq 0x3b71(%rip), %rsi      # 0x50c4
movl $0xc, %edx
leaq 0x3b70(%rip), %rcx      # 0x50cf
callq 0x10e0
movq -0x10(%rbp), %rdi
callq 0x10a0
cmpq $0x4, %rax
je 0x1594
movq 0x6a5e(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
leaq 0x3b70(%rip), %rsi      # 0x50f4
movb $0x0, %al
callq 0x1180
movl $0x0, -0x4(%rbp)
jmp 0x15c5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
shll $0x18, %eax
movq -0x10(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movsbl 0x3(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: report_decoding_test_result
int
report_decoding_test_result(
    TestTracker *tracker,
    struct kmip *ctx,
    int comparison,
    int result,
    const char *function)
{
    if(result == KMIP_OK)
    {
        if(comparison)
        {
            TEST_PASSED(tracker, function);
        }
        else
        {
            printf("FAIL - %s\n", function);
            printf("- compared objects are not identical\n");
            tracker->tests_failed++;
            return(1);
        }
    }
    else
    {
        printf("FAIL - %s\n", function);
        if(result == KMIP_ERROR_BUFFER_FULL)
        {
            printf("- context buffer is underfull\n");
        }
        kmip_print_stack_trace(stderr, ctx);
        tracker->tests_failed++;
        return(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x142f
cmpl $0x0, -0x1c(%rbp)
je 0x13f6
jmp 0x13c8
movq -0x28(%rbp), %rsi
leaq 0x3dc78(%rip), %rdi     # 0x3f04b
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rax
movw 0x4(%rax), %cx
addw $0x1, %cx
movw %cx, 0x4(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x147f
movq -0x28(%rbp), %rsi
leaq 0x3dc03(%rip), %rdi     # 0x3f004
movb $0x0, %al
callq 0x1070
leaq 0x3dc61(%rip), %rdi     # 0x3f070
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rax
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x147f
movq -0x28(%rbp), %rsi
leaq 0x3dbca(%rip), %rdi     # 0x3f004
movb $0x0, %al
callq 0x1070
cmpl $-0x2, -0x20(%rbp)
jne 0x1455
leaq 0x3dc48(%rip), %rdi     # 0x3f096
movb $0x0, %al
callq 0x1070
movq 0x52b9c(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x38260
movq -0x10(%rbp), %rax
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: report_result
int
report_result(TestTracker *tracker, int observed, int expected, const char *function)
{
    if(observed == expected)
    {
        TEST_PASSED(tracker, function);
    }
    else
    {
        printf("FAIL - %s\n", function);
        tracker->tests_failed++;
        return(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x14db
jmp 0x14b0
movq -0x20(%rbp), %rsi
leaq 0x3db90(%rip), %rdi     # 0x3f04b
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rax
movw 0x4(%rax), %cx
addw $0x1, %cx
movw %cx, 0x4(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1504
movq -0x20(%rbp), %rsi
leaq 0x3db1e(%rip), %rdi     # 0x3f004
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rax
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_is_tag_next
int
test_is_tag_next(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 encoding[3] = {0x42, 0x00, 0x08};
    
    struct kmip ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
    
    uint8 *before = ctx.index;
    int result = 0;
    
    if(kmip_is_tag_next(&ctx, KMIP_TAG_ATTRIBUTE) == KMIP_FALSE)
    {
        printf("FAIL - %s\n", __func__);
        printf("- expected tag is not next\n");
        tracker->tests_failed++;
        result = 1;
    }
    
    uint8 *after = ctx.index;
    
    if(before != after)
    {
        printf("FAIL - %s\n", __func__);
        printf("- tag checking modifies context buffer index\n");
        tracker->tests_failed++;
        result = 1;
    }
    
    kmip_destroy(&ctx);
    
    if(result == 0)
    {
        printf("PASS - %s\n", __func__);
        tracker->tests_passed++;
    }
    
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8c0, %rsp            # imm = 0x8C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movw 0x3f664(%rip), %ax      # 0x41678
movw %ax, -0xb(%rbp)
movb 0x3f65c(%rip), %al      # 0x4167a
movb %al, -0x9(%rbp)
leaq -0x8a8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0xb(%rbp), %rsi
leaq -0x8a8(%rbp), %rdi
movl $0x3, %edx
xorl %ecx, %ecx
callq 0x1c6e0
movq -0x8a0(%rbp), %rax
movq %rax, -0x8b0(%rbp)
movl $0x0, -0x8b4(%rbp)
leaq -0x8a8(%rbp), %rdi
movl $0x420008, %esi         # imm = 0x420008
callq 0x1cdc0
cmpl $0x0, %eax
jne 0x20b6
leaq 0x3cf84(%rip), %rdi     # 0x3f004
leaq 0x3d0b7(%rip), %rsi     # 0x3f13e
movb $0x0, %al
callq 0x1070
leaq 0x3d0ba(%rip), %rdi     # 0x3f14f
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
movl $0x1, -0x8b4(%rbp)
movq -0x8a0(%rbp), %rax
movq %rax, -0x8c0(%rbp)
movq -0x8b0(%rbp), %rax
cmpq -0x8c0(%rbp), %rax
je 0x2111
leaq 0x3cf29(%rip), %rdi     # 0x3f004
leaq 0x3d05c(%rip), %rsi     # 0x3f13e
movb $0x0, %al
callq 0x1070
leaq 0x3d07b(%rip), %rdi     # 0x3f16b
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
movl $0x1, -0x8b4(%rbp)
leaq -0x8a8(%rbp), %rdi
callq 0x1cab0
cmpl $0x0, -0x8b4(%rbp)
jne 0x214b
leaq 0x3cf1e(%rip), %rdi     # 0x3f04b
leaq 0x3d00a(%rip), %rsi     # 0x3f13e
movb $0x0, %al
callq 0x1070
movq -0x8(%rbp), %rax
movw 0x4(%rax), %cx
addw $0x1, %cx
movw %cx, 0x4(%rax)
movl -0x8b4(%rbp), %eax
addq $0x8c0, %rsp            # imm = 0x8C0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_int8_be
int
test_decode_int8_be(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 encoding[1] = {0x42};
    
    struct kmip ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
    
    int8 value = 0;
    
    int result = kmip_decode_int8_be(&ctx, &value);
    result = report_decoding_test_result(
        tracker,
        &ctx,
        value == 0x42, 
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8b0, %rsp            # imm = 0x8B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movb 0x3b2c5(%rip), %al      # 0x41928
movb %al, -0x9(%rbp)
leaq -0x8a8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x9(%rbp), %rsi
leaq -0x8a8(%rbp), %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x1c6e0
movb $0x0, -0x8a9(%rbp)
leaq -0x8a8(%rbp), %rdi
leaq -0x8a9(%rbp), %rsi
callq 0x2abd0
movl %eax, -0x8b0(%rbp)
movq -0x8(%rbp), %rdi
movsbl -0x8a9(%rbp), %eax
cmpl $0x42, %eax
sete %al
andb $0x1, %al
movzbl %al, %edx
movl -0x8b0(%rbp), %ecx
leaq -0x8a8(%rbp), %rsi
leaq 0x38ea2(%rip), %r8      # 0x3f57c
callq 0x13a0
movl %eax, -0x8b0(%rbp)
leaq -0x8a8(%rbp), %rdi
callq 0x1cab0
movl -0x8b0(%rbp), %eax
addq $0x8b0, %rsp            # imm = 0x8B0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_int32_be
int
test_decode_int32_be(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 encoding[4] = {0x11, 0x22, 0x33, 0x44};
    
    struct kmip ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);

    int32 expected = 0x11223344;
    int32 observed = 0;
    
    int result = kmip_decode_int32_be(&ctx, &observed);
    result = report_decoding_test_result(
        tracker,
        &ctx,
        observed == expected,
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8c0, %rsp            # imm = 0x8C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movl 0x409f9(%rip), %eax     # 0x4711c
movl %eax, -0xc(%rbp)
leaq -0x8a8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0xc(%rbp), %rsi
leaq -0x8a8(%rbp), %rdi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x1c6e0
movl $0x11223344, -0x8ac(%rbp) # imm = 0x11223344
movl $0x0, -0x8b0(%rbp)
leaq -0x8a8(%rbp), %rdi
leaq -0x8b0(%rbp), %rsi
callq 0x2ac60
movl %eax, -0x8b4(%rbp)
movq -0x8(%rbp), %rdi
movl -0x8b0(%rbp), %eax
cmpl -0x8ac(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edx
movl -0x8b4(%rbp), %ecx
leaq -0x8a8(%rbp), %rsi
leaq 0x38de7(%rip), %r8      # 0x3f590
callq 0x13a0
movl %eax, -0x8b4(%rbp)
leaq -0x8a8(%rbp), %rdi
callq 0x1cab0
movl -0x8b4(%rbp), %eax
addq $0x8c0, %rsp            # imm = 0x8C0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_int64_be
int
test_decode_int64_be(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 encoding[8] = {
        0x01, 0xB6, 0x9B, 0x4B, 0xA5, 0x74, 0x92, 0x00
    };
    
    struct kmip ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
    
    int64 expected = 0x01B69B4BA5749200;
    int64 observed = 0;
    
    int result = kmip_decode_int64_be(&ctx, &observed);
    result = report_decoding_test_result(
        tracker,
        &ctx,
        observed == expected,
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8c0, %rsp            # imm = 0x8C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x38db1(%rip), %rax     # 0x3f5a5
movq %rax, -0x10(%rbp)
leaq -0x8a8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x10(%rbp), %rsi
leaq -0x8a8(%rbp), %rdi
movl $0x8, %edx
xorl %ecx, %ecx
callq 0x1c6e0
movabsq $0x1b69b4ba5749200, %rax # imm = 0x1B69B4BA5749200
movq %rax, -0x8b0(%rbp)
movq $0x0, -0x8b8(%rbp)
leaq -0x8a8(%rbp), %rdi
leaq -0x8b8(%rbp), %rsi
callq 0x2ad60
movl %eax, -0x8bc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8b8(%rbp), %rax
cmpq -0x8b0(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %edx
movl -0x8bc(%rbp), %ecx
leaq -0x8a8(%rbp), %rsi
leaq 0x38d28(%rip), %r8      # 0x3f5ad
callq 0x13a0
movl %eax, -0x8bc(%rbp)
leaq -0x8a8(%rbp), %rdi
callq 0x1cab0
movl -0x8bc(%rbp), %eax
addq $0x8c0, %rsp            # imm = 0x8C0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_encode_integer
int
test_encode_integer(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 expected[16] = {
        0x42, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00
    };
    
    uint8 observed[16] = {0};
    struct kmip ctx = {0};
    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
    
    int result = kmip_encode_integer(&ctx, KMIP_TAG_DEFAULT, 8);
    result = report_encoding_test_result(
        tracker,
        &ctx,
        expected,
        observed,
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x4084c(%rip), %rax     # 0x47120
movq %rax, -0x20(%rbp)
movq 0x40849(%rip), %rax     # 0x47128
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8c8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x30(%rbp), %rsi
leaq -0x8c8(%rbp), %rdi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x1c6e0
leaq -0x8c8(%rbp), %rdi
movl $0x420000, %esi         # imm = 0x420000
movl $0x8, %edx
callq 0x24df0
movl %eax, -0x8cc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl -0x8cc(%rbp), %r8d
leaq -0x8c8(%rbp), %rsi
leaq 0x38c68(%rip), %r9      # 0x3f5c2
callq 0x11f0
movl %eax, -0x8cc(%rbp)
leaq -0x8c8(%rbp), %rdi
callq 0x1cab0
movl -0x8cc(%rbp), %eax
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_integer
int
test_decode_integer(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 encoding[16] = {
        0x42, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00
    };

    struct kmip ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
    
    int32 expected = 8;
    int32 observed = 0;
    
    int result = kmip_decode_integer(&ctx, KMIP_TAG_DEFAULT, &observed);
    result = report_decoding_test_result(
        tracker,
        &ctx,
        observed == expected,
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x4077c(%rip), %rax     # 0x47120
movq %rax, -0x20(%rbp)
movq 0x40779(%rip), %rax     # 0x47128
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x1c6e0
movl $0x8, -0x8bc(%rbp)
movl $0x0, -0x8c0(%rbp)
leaq -0x8b8(%rbp), %rdi
movl $0x420000, %esi         # imm = 0x420000
leaq -0x8c0(%rbp), %rdx
callq 0x2afb0
movl %eax, -0x8c4(%rbp)
movq -0x8(%rbp), %rdi
movl -0x8c0(%rbp), %eax
cmpl -0x8bc(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edx
movl -0x8c4(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x38b9b(%rip), %r8      # 0x3f5d6
callq 0x13a0
movl %eax, -0x8c4(%rbp)
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8c4(%rbp), %eax
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_encode_long
int
test_encode_long(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 expected[16] = {
        0x42, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08,
        0x01, 0xB6, 0x9B, 0x4B, 0xA5, 0x74, 0x92, 0x00
    };
    
    uint8 observed[16] = {0};
    struct kmip ctx = {0};
    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
    
    int result = kmip_encode_long(&ctx, KMIP_TAG_DEFAULT, 123456789000000000);
    result = report_encoding_test_result(
        tracker,
        &ctx,
        expected,
        observed,
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x4069c(%rip), %rax     # 0x47130
movq %rax, -0x20(%rbp)
movq 0x40699(%rip), %rax     # 0x47138
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8c8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x30(%rbp), %rsi
leaq -0x8c8(%rbp), %rdi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x1c6e0
leaq -0x8c8(%rbp), %rdi
movl $0x420000, %esi         # imm = 0x420000
movabsq $0x1b69b4ba5749200, %rdx # imm = 0x1B69B4BA5749200
callq 0x24e90
movl %eax, -0x8cc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl -0x8cc(%rbp), %r8d
leaq -0x8c8(%rbp), %rsi
leaq 0x38acb(%rip), %r9      # 0x3f5ea
callq 0x11f0
movl %eax, -0x8cc(%rbp)
leaq -0x8c8(%rbp), %rdi
callq 0x1cab0
movl -0x8cc(%rbp), %eax
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_long
int
test_decode_long(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 encoding[16] = {
        0x42, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08,
        0x01, 0xB6, 0x9B, 0x4B, 0xA5, 0x74, 0x92, 0x00
    };
    
    struct kmip ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
    
    int64 expected = 0x01B69B4BA5749200;
    int64 observed = 0;
    
    int result = kmip_decode_long(&ctx, KMIP_TAG_DEFAULT, &observed);
    result = report_decoding_test_result(
        tracker,
        &ctx,
        observed == expected,
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x405bc(%rip), %rax     # 0x47130
movq %rax, -0x20(%rbp)
movq 0x405b9(%rip), %rax     # 0x47138
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x1c6e0
movabsq $0x1b69b4ba5749200, %rax # imm = 0x1B69B4BA5749200
movq %rax, -0x8c0(%rbp)
movq $0x0, -0x8c8(%rbp)
leaq -0x8b8(%rbp), %rdi
movl $0x420000, %esi         # imm = 0x420000
leaq -0x8c8(%rbp), %rdx
callq 0x2b110
movl %eax, -0x8cc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8c8(%rbp), %rax
cmpq -0x8c0(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %edx
movl -0x8cc(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x389e6(%rip), %r8      # 0x3f5fb
callq 0x13a0
movl %eax, -0x8cc(%rbp)
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8cc(%rbp), %eax
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_encode_enum
int
test_encode_enum(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 expected[16] = {
        0x42, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00
    };
    
    uint8 observed[16] = {0};
    struct kmip ctx = {0};
    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
    
    int result = kmip_encode_enum(&ctx, KMIP_TAG_DEFAULT, KMIP_CRYPTOALG_AES);
    result = report_encoding_test_result(
        tracker,
        &ctx,
        expected,
        observed,
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x404dc(%rip), %rax     # 0x47140
movq %rax, -0x20(%rbp)
movq 0x404d9(%rip), %rax     # 0x47148
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8c8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x30(%rbp), %rsi
leaq -0x8c8(%rbp), %rdi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x1c6e0
leaq -0x8c8(%rbp), %rdi
movl $0x420000, %esi         # imm = 0x420000
movl $0x3, %edx
callq 0x24f30
movl %eax, -0x8cc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl -0x8cc(%rbp), %r8d
leaq -0x8c8(%rbp), %rsi
leaq 0x38922(%rip), %r9      # 0x3f60c
callq 0x11f0
movl %eax, -0x8cc(%rbp)
leaq -0x8c8(%rbp), %rdi
callq 0x1cab0
movl -0x8cc(%rbp), %eax
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_enum
int
test_decode_enum(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 encoding[16] = {
        0x42, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00
    };
    
    struct kmip ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
    
    enum cryptographic_algorithm expected = KMIP_CRYPTOALG_AES;
    enum cryptographic_algorithm observed = 0;
    
    int result = kmip_decode_enum(&ctx, KMIP_TAG_DEFAULT, &observed);
    result = report_decoding_test_result(
        tracker,
        &ctx,
        observed == expected,
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x4040c(%rip), %rax     # 0x47140
movq %rax, -0x20(%rbp)
movq 0x40409(%rip), %rax     # 0x47148
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x1c6e0
movl $0x3, -0x8bc(%rbp)
movl $0x0, -0x8c0(%rbp)
leaq -0x8b8(%rbp), %rdi
movl $0x420000, %esi         # imm = 0x420000
leaq -0x8c0(%rbp), %rdx
callq 0x2b230
movl %eax, -0x8c4(%rbp)
movq -0x8(%rbp), %rdi
movl -0x8c0(%rbp), %eax
cmpl -0x8bc(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edx
movl -0x8c4(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x38852(%rip), %r8      # 0x3f61d
callq 0x13a0
movl %eax, -0x8c4(%rbp)
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8c4(%rbp), %eax
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_encode_bool
int
test_encode_bool(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 expected[16] = {
        0x42, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
    };
    
    uint8 observed[16] = {0};
    struct kmip ctx = {0};
    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);
    
    int result = kmip_encode_bool(&ctx, KMIP_TAG_DEFAULT, KMIP_TRUE);
    result = report_encoding_test_result(
        tracker,
        &ctx,
        expected,
        observed,
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x4032c(%rip), %rax     # 0x47150
movq %rax, -0x20(%rbp)
movq 0x40329(%rip), %rax     # 0x47158
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8c8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x30(%rbp), %rsi
leaq -0x8c8(%rbp), %rdi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x1c6e0
leaq -0x8c8(%rbp), %rdi
movl $0x420000, %esi         # imm = 0x420000
movl $0x1, %edx
callq 0x24fd0
movl %eax, -0x8cc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl -0x8cc(%rbp), %r8d
leaq -0x8c8(%rbp), %rsi
leaq 0x38784(%rip), %r9      # 0x3f62e
callq 0x11f0
movl %eax, -0x8cc(%rbp)
leaq -0x8c8(%rbp), %rdi
callq 0x1cab0
movl -0x8cc(%rbp), %eax
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_bool
int
test_decode_bool(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 encoding[16] = {
        0x42, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
    };
    
    struct kmip ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_0);
    
    bool32 expected = KMIP_TRUE;
    bool32 observed = 0;
    
    int result = kmip_decode_bool(&ctx, KMIP_TAG_DEFAULT, &observed);
    result = report_decoding_test_result(
        tracker,
        &ctx,
        observed == expected,
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x4025c(%rip), %rax     # 0x47150
movq %rax, -0x20(%rbp)
movq 0x40259(%rip), %rax     # 0x47158
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x1c6e0
movl $0x1, -0x8bc(%rbp)
movl $0x0, -0x8c0(%rbp)
leaq -0x8b8(%rbp), %rdi
movl $0x420000, %esi         # imm = 0x420000
leaq -0x8c0(%rbp), %rdx
callq 0x2b3a0
movl %eax, -0x8c4(%rbp)
movq -0x8(%rbp), %rdi
movl -0x8c0(%rbp), %eax
cmpl -0x8bc(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edx
movl -0x8c4(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x386b4(%rip), %r8      # 0x3f63f
callq 0x13a0
movl %eax, -0x8c4(%rbp)
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8c4(%rbp), %eax
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
nopw %cs:(%rax,%rax)