LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_parser.c
// Function: dx_codeitem
DexCodeItem* dx_codeitem(ByteStream* bs, uint32_t offset) {
  DexCodeItem* res;
  unsigned int i;

  DX_ALLOC(DexCodeItem,res);

  bsseek(bs,offset);

  bsread(bs,(uint8_t*) &(res->registers_size),sizeof(uint16_t));
  bsread(bs,(uint8_t*) &(res->ins_size),sizeof(uint16_t));
  bsread(bs,(uint8_t*) &(res->outs_size),sizeof(uint16_t));
  bsread(bs,(uint8_t*) &(res->tries_size),sizeof(uint16_t));
  bsread(bs,(uint8_t*) &(res->debug_info_off),sizeof(uint32_t));
  bsread(bs,(uint8_t*) &(res->insns_size),sizeof(uint32_t));

  res->meta.corrupted = bs->exhausted;
  if (res->meta.corrupted) return res;

  DX_ALLOC_LIST(uint16_t,res->insns,res->insns_size);

  for (i=0; i<res->insns_size; i++)
    bsread(bs,(uint8_t*) &(res->insns[i]),sizeof(uint16_t));

  if (res->tries_size > 0) {
    if (res->insns_size % 2 != 0)
      bsread(bs,(uint8_t*) &(res->padding),sizeof(uint16_t));

    DX_ALLOC_LIST(DexTryItem*,res->tries,res->tries_size); 
   
    for (i=0; i<res->tries_size; i++)
      res->tries[i] = dx_tryitem(bs,bs->offset);

    res->handlers = dx_encodedcatchhandlerlist(bs,bs->offset);    
  }

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl $0x38, %edi
callq 0x4600
movq %rax, %rbx
movl %ebp, 0x4(%rax)
movb $0x0, (%rax)
movq %r14, %rdi
movl %ebp, %esi
callq 0x4410
leaq 0x8(%rbx), %rsi
movl $0x2, %edx
movq %r14, %rdi
callq 0x4420
leaq 0xa(%rbx), %rsi
movl $0x2, %edx
movq %r14, %rdi
callq 0x4420
leaq 0xc(%rbx), %rsi
movl $0x2, %edx
movq %r14, %rdi
callq 0x4420
leaq 0xe(%rbx), %r15
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4420
leaq 0x10(%rbx), %rsi
movl $0x4, %edx
movq %r14, %rdi
callq 0x4420
leaq 0x14(%rbx), %r12
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4420
cmpl $0x0, 0x1c(%r14)
setne (%rbx)
jne 0x6aef
movl (%r12), %edi
testq %rdi, %rdi
je 0x6a68
addq %rdi, %rdi
callq 0x4600
cmpl $0x0, 0x14(%rbx)
movq %rax, 0x18(%rbx)
je 0x6a70
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x18(%rbx), %rsi
addq %r12, %rsi
movl $0x2, %edx
movq %r14, %rdi
callq 0x4420
incq %r13
movl 0x14(%rbx), %eax
addq $0x2, %r12
cmpq %rax, %r13
jb 0x6a3e
testb $0x1, %al
sete %cl
jmp 0x6a72
movq $0x0, 0x18(%rbx)
movb $0x1, %cl
movzwl (%r15), %eax
testw %ax, %ax
je 0x6aef
testb %cl, %cl
jne 0x6a9c
movq %rbx, %rsi
addq $0x20, %rsi
movl $0x2, %edx
movq %r14, %rdi
callq 0x4420
movzwl 0xe(%rbx), %eax
testw %ax, %ax
je 0x6ad7
movzwl %ax, %edi
shll $0x3, %edi
callq 0x4600
movq %rax, 0x28(%rbx)
cmpw $0x0, 0xe(%rbx)
je 0x6adf
xorl %r15d, %r15d
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x4760
movq 0x28(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movzwl 0xe(%rbx), %eax
cmpq %rax, %r15
jb 0x6ab5
jmp 0x6adf
movq $0x0, 0x28(%rbx)
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x41f0
movq %rax, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_parser.c
// Function: dx_debuginfo
DexDebugInfo* dx_debuginfo(ByteStream* bs, uint32_t offset) {
  DexDebugInfo* res;
  int check;
  unsigned int i;

  if (bs == NULL) return NULL;

  DX_ALLOC(DexDebugInfo,res);

  bsseek(bs,offset);

  check  = l128read(bs,&(res->line_start));
  check |= l128read(bs,&(res->parameters_size));

  res->meta.corrupted = check || bs->exhausted;
  if (res->meta.corrupted) return res;

  DX_ALLOC_LIST(leb128_t,res->parameter_names,ul128toui(res->parameters_size));

  for (i=0; i<ul128toui(res->parameters_size); i++)
    l128read(bs,&(res->parameter_names[i]));

  res->state_machine = dx_debug_state_machine(bs,bs->offset);

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x6b59
movl %esi, %ebp
movq %rdi, %r14
movl $0x30, %edi
callq 0x4600
movq %rax, %rbx
movl %ebp, 0x4(%rax)
movb $0x0, (%rax)
movq %r14, %rdi
movl %ebp, %esi
callq 0x4410
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4750
movl %eax, %ebp
movq %rbx, %rsi
addq $0x14, %rsi
movq %r14, %rdi
callq 0x4750
orl %ebp, %eax
je 0x6b60
movb $0x1, (%rbx)
jmp 0x6bf0
xorl %ebx, %ebx
jmp 0x6bf0
cmpl $0x0, 0x1c(%r14)
setne (%rbx)
jne 0x6bf0
movq 0x14(%rbx), %rdi
movl 0x1c(%rbx), %esi
callq 0x4170
testl %eax, %eax
je 0x6b9b
movq 0x14(%rbx), %rdi
movl 0x1c(%rbx), %esi
callq 0x4170
movl %eax, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdi
callq 0x4600
jmp 0x6b9d
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movq 0x14(%rbx), %rdi
movl 0x1c(%rbx), %esi
callq 0x4170
testl %eax, %eax
je 0x6be0
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x20(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x4750
incq %r12
movq 0x14(%rbx), %rdi
movl 0x1c(%rbx), %esi
callq 0x4170
movl %eax, %eax
addq $0xc, %r15
cmpq %rax, %r12
jb 0x6bb7
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x4140
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_parser.c
// Function: dx_debug_state_machine
uint8_t* dx_debug_state_machine(ByteStream* bs, uint32_t offset) {
  uint32_t size = 1;
  uint8_t opcode;
  leb128_t leb;
  uint8_t* res;

  bsseek(bs,offset);
  bsread(bs,&opcode,1);

  while (opcode != 0x0) {
    switch (opcode) {
    case 0x1:
    case 0x2:
    case 0x5:
    case 0x6:
    case 0x9:
      l128read(bs,&leb);
      break;
    case 0x3:
      l128read(bs,&leb);
      l128read(bs,&leb);
      l128read(bs,&leb);
      break;
    case 0x4:
      l128read(bs,&leb);
      l128read(bs,&leb);
      l128read(bs,&leb);
      l128read(bs,&leb);
    default:
      break;
    }

    bsread(bs,&opcode,1);
  }

  size = bs->offset - offset;

  DX_ALLOC_LIST(uint8_t,res,size + sizeof(uint32_t));  

  bsseek(bs,offset);
  bsread(bs,(res+sizeof(uint32_t)),size);

  ((uint32_t*) res)[0] = size;

  return res;    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x4410
leaq 0x3(%rsp), %r14
leaq 0x351e(%rip), %r12      # 0xa13c
leaq 0x4(%rsp), %r15
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4420
movzbl 0x3(%rsp), %eax
cmpq $0x9, %rax
ja 0x6c23
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4750
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4750
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4750
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4750
jmp 0x6c23
movl 0x18(%rbx), %r14d
subl %ebp, %r14d
leaq 0x4(%r14), %rdi
callq 0x4600
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4410
leaq 0x4(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4420
movl %r14d, (%r15)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_parser.c
// Function: dx_maplist
DexMapList* dx_maplist(ByteStream* bs, uint32_t offset) {
  DexMapList* res;
  int check;
  unsigned int i;

  if (bs == NULL) return NULL;

  DX_ALLOC(DexMapList,res);

  bsseek(bs,offset);

  check = bsread(bs,(uint8_t*)&(res->size),sizeof(uint32_t));

  res->meta.corrupted = (check != sizeof(uint32_t));
  if (res->meta.corrupted) return res;

  DX_ALLOC_LIST(DexMapItem*,res->list,res->size);  

  for (i=0; i<res->size; i++)
    res->list[i] = dx_mapitem(bs,bs->offset);

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6d92
movl %esi, %ebp
movq %rdi, %r14
movl $0x18, %edi
callq 0x4600
movq %rax, %rbx
movl %ebp, 0x4(%rax)
movb $0x0, (%rax)
movq %r14, %rdi
movl %ebp, %esi
callq 0x4410
leaq 0x8(%rbx), %r15
movl $0x4, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4420
cmpl $0x4, %eax
setne (%rbx)
jne 0x6d9e
movl (%r15), %edi
testq %rdi, %rdi
je 0x6d96
shlq $0x3, %rdi
callq 0x4600
cmpl $0x0, 0x8(%rbx)
movq %rax, 0x10(%rbx)
je 0x6d9e
xorl %r15d, %r15d
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x4100
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movl 0x8(%rbx), %eax
cmpq %rax, %r15
jb 0x6d71
jmp 0x6d9e
xorl %ebx, %ebx
jmp 0x6d9e
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_parser.c
// Function: dx_encodedvalue
DexEncodedValue* dx_encodedvalue(ByteStream* bs, uint32_t offset) {
  DexEncodedValue* res;
  int check;
  int i;

  uint8_t value_type;
  uint8_t value_arg;

  if (bs == NULL) return NULL;

  bsseek(bs,offset);

  DX_ALLOC(DexEncodedValue,res);

  check = bsread(bs,(uint8_t*)&(res->argtype),sizeof(uint8_t));

  res->meta.corrupted = (check != sizeof(uint8_t));
  if (res->meta.corrupted) return res;

  value_type = (res->argtype & 0x1f);
  value_arg  = ((res->argtype >> 5) & 0x7);
	       
  switch (value_type) {
  case 0x00:
    DX_ALLOC_LIST(uint8_t,res->value,1);
    bsread(bs,(uint8_t*) res->value,sizeof(uint8_t));
    break;
  case 0x02:
  case 0x03:
  case 0x04:
  case 0x06:
  case 0x10:
  case 0x11:
  case 0x17:
  case 0x18:
  case 0x19:
  case 0x1a:
  case 0x1b:
    DX_ALLOC_LIST(uint8_t,res->value,value_arg+1);

    for (i=0; i<value_arg+1; i++)
      bsread(bs,(uint8_t*) &(res->value[i]),sizeof(uint8_t));   

    break;
  case 0x1c:
    res->value = (uint8_t*) dx_encodedarray(bs,bs->offset);
    break;
  case 0x1d:
    res->value = (uint8_t*) dx_encodedannotation(bs,bs->offset);
    break;
  case 0x1e:
  case 0x1f:
    res->value = NULL;
  default:
    res->meta.corrupted = true;
    res->value = (uint8_t*) -1;
  }

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x6e4d
movl %esi, %ebp
movq %rdi, %r14
callq 0x4410
movl $0x18, %edi
callq 0x4600
movq %rax, %rbx
movl %ebp, 0x4(%rax)
movb $0x0, (%rax)
leaq 0x8(%rax), %r15
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4420
cmpl $0x1, %eax
setne (%rbx)
jne 0x6e4f
movzbl (%r15), %r15d
movl %r15d, %eax
andl $0x1f, %eax
cmpl $0x1d, %eax
ja 0x6e9b
leaq 0x3354(%rip), %rcx      # 0xa164
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x5, %r15d
incq %r15
movq %r15, %rdi
callq 0x4600
movq %rax, 0x10(%rbx)
xorl %r12d, %r12d
movq 0x10(%rbx), %rsi
addq %r12, %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x4420
incq %r12
cmpq %r12, %r15
jne 0x6e2f
jmp 0x6e4f
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x4600
movq %rax, 0x10(%rbx)
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x4420
jmp 0x6e4f
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x4150
jmp 0x6e95
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x4730
movq %rax, 0x10(%rbx)
jmp 0x6e4f
movb $0x1, (%rbx)
movq $-0x1, 0x10(%rbx)
jmp 0x6e4f
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_parser.c
// Function: dx_encodedarray
DexEncodedArray* dx_encodedarray(ByteStream* bs, uint32_t offset) {
  DexEncodedArray* res;
  int check;
  unsigned int i;

  if (bs == NULL) return NULL;

  bsseek(bs,offset);

  DX_ALLOC(DexEncodedArray,res);

  check = l128read(bs,&(res->size));

  res->meta.corrupted = (check || bs->exhausted);
  if (res->meta.corrupted) return res;

  DX_ALLOC_LIST(DexEncodedValue*,res->values,ul128toui(res->size));

  for (i=0; i<ul128toui(res->size); i++)
    res->values[i] = dx_encodedvalue(bs,bs->offset);

  return res;  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6ee6
movl %esi, %ebp
movq %rdi, %r14
callq 0x4410
movl $0x20, %edi
callq 0x4600
movq %rax, %rbx
movl %ebp, 0x4(%rax)
movb $0x0, (%rax)
leaq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x4750
testl %eax, %eax
je 0x6eea
movb $0x1, (%rbx)
jmp 0x6f60
xorl %ebx, %ebx
jmp 0x6f60
cmpl $0x0, 0x1c(%r14)
setne (%rbx)
jne 0x6f60
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0x4170
testl %eax, %eax
je 0x6f1d
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0x4170
movl %eax, %edi
shlq $0x3, %rdi
callq 0x4600
jmp 0x6f1f
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0x4170
testl %eax, %eax
je 0x6f60
xorl %r15d, %r15d
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x47c0
movq 0x18(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0x4170
movl %eax, %eax
cmpq %rax, %r15
jb 0x6f36
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_parser.c
// Function: dx_encodedannotation
DexEncodedAnnotation* dx_encodedannotation(ByteStream* bs, uint32_t offset) {
  DexEncodedAnnotation* res;
  int check;
  unsigned int i;

  if (bs == NULL) return NULL;

  bsseek(bs,offset);

  DX_ALLOC(DexEncodedAnnotation,res);

  check  = l128read(bs,&(res->type_idx));
  check |= l128read(bs,&(res->size));

  res->meta.corrupted = (check || bs->exhausted);
  if (res->meta.corrupted) return res;

  DX_ALLOC_LIST(DexAnnotationElement*,res->elements,ul128toui(res->size));

  for (i=0; i<ul128toui(res->size); i++)
    res->elements[i] = dx_annotationelement(bs,bs->offset);

  return res;  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6fbd
movl %esi, %ebp
movq %rdi, %r14
callq 0x4410
movl $0x28, %edi
callq 0x4600
movq %rax, %rbx
movl %ebp, 0x4(%rax)
movb $0x0, (%rax)
leaq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x4750
movl %eax, %ebp
movq %rbx, %rsi
addq $0x14, %rsi
movq %r14, %rdi
callq 0x4750
orl %ebp, %eax
je 0x6fc1
movb $0x1, (%rbx)
jmp 0x7037
xorl %ebx, %ebx
jmp 0x7037
cmpl $0x0, 0x1c(%r14)
setne (%rbx)
jne 0x7037
movq 0x14(%rbx), %rdi
movl 0x1c(%rbx), %esi
callq 0x4170
testl %eax, %eax
je 0x6ff4
movq 0x14(%rbx), %rdi
movl 0x1c(%rbx), %esi
callq 0x4170
movl %eax, %edi
shlq $0x3, %rdi
callq 0x4600
jmp 0x6ff6
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movq 0x14(%rbx), %rdi
movl 0x1c(%rbx), %esi
callq 0x4170
testl %eax, %eax
je 0x7037
xorl %r15d, %r15d
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x4270
movq 0x20(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movq 0x14(%rbx), %rdi
movl 0x1c(%rbx), %esi
callq 0x4170
movl %eax, %eax
cmpq %rax, %r15
jb 0x700d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_parser.c
// Function: dx_annotationelement
DexAnnotationElement* dx_annotationelement(ByteStream* bs, uint32_t offset) {
  DexAnnotationElement* res;
  int check;

  if (bs == NULL) return NULL;

  bsseek(bs,offset);

  DX_ALLOC(DexAnnotationElement,res);

  check = l128read(bs,&(res->name_idx));

  res->value = dx_encodedvalue(bs,bs->offset);

  res->meta.corrupted = (check || bs->exhausted);

  return res;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x709a
movl %esi, %ebp
movq %rdi, %rbx
callq 0x4410
movl $0x20, %edi
callq 0x4600
movq %rax, %r14
movl %ebp, 0x4(%rax)
movb $0x0, (%rax)
leaq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x4750
movl %eax, %ebp
movl 0x18(%rbx), %esi
movq %rbx, %rdi
callq 0x47c0
movq %rax, 0x18(%r14)
movb $0x1, %al
testl %ebp, %ebp
jne 0x7095
cmpl $0x0, 0x1c(%rbx)
setne %al
movb %al, (%r14)
jmp 0x709d
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_parser.c
// Function: dx_annotationsetreflist
DexAnnotationSetRefList* dx_annotationsetreflist(ByteStream* bs, uint32_t offset) {
  DexAnnotationSetRefList* res;
  int check;
  unsigned int i;

  if (bs == NULL) return NULL;

  DX_ALLOC(DexAnnotationSetRefList,res);

  bsseek(bs,offset);

  check  = bsread(bs,(uint8_t*) &(res->size),sizeof(uint32_t));

  res->meta.corrupted = (check != sizeof(uint32_t) || bs->exhausted);
  if (res->meta.corrupted) return res;

  DX_ALLOC_LIST(DexAnnotationSetRefItem*,res->list,res->size);

  for (i=0; i<res->size; i++)
    res->list[i] = dx_annotationsetrefitem(bs,bs->offset);

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x741e
movl %esi, %ebp
movq %rdi, %r14
movl $0x18, %edi
callq 0x4600
movq %rax, %rbx
movl %ebp, 0x4(%rax)
movb $0x0, (%rax)
movq %r14, %rdi
movl %ebp, %esi
callq 0x4410
movq %rbx, %r15
addq $0x8, %r15
movl $0x4, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4420
cmpl $0x4, %eax
jne 0x7422
cmpl $0x0, 0x1c(%r14)
setne (%rbx)
jne 0x7425
movl (%r15), %edi
testq %rdi, %rdi
je 0x7433
shlq $0x3, %rdi
callq 0x4600
cmpl $0x0, 0x8(%rbx)
movq %rax, 0x10(%rbx)
je 0x7425
xorl %r15d, %r15d
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x4430
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movl 0x8(%rbx), %eax
cmpq %rax, %r15
jb 0x73fd
jmp 0x7425
xorl %ebx, %ebx
jmp 0x7425
movb $0x1, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, 0x10(%rbx)
jmp 0x7425
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_parser.c
// Function: dx_annotationsetitem
DexAnnotationSetItem* dx_annotationsetitem(ByteStream* bs, uint32_t offset) {
  DexAnnotationSetItem* res;
  int check;
  unsigned int i;

  if (bs == NULL) return NULL;

  DX_ALLOC(DexAnnotationSetItem,res);

  bsseek(bs,offset);

  check  = bsread(bs,(uint8_t*) &(res->size),sizeof(uint32_t));

  res->meta.corrupted = (check != sizeof(uint32_t) || bs->exhausted);
  if (res->meta.corrupted) return res;

  DX_ALLOC_LIST(DexAnnotationOffItem*,res->entries,res->size);

  for (i=0; i<res->size; i++)
    res->entries[i] = dx_annotationoffitem(bs,bs->offset);

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7529
movl %esi, %ebp
movq %rdi, %r14
movl $0x18, %edi
callq 0x4600
movq %rax, %rbx
movl %ebp, 0x4(%rax)
movb $0x0, (%rax)
movq %r14, %rdi
movl %ebp, %esi
callq 0x4410
movq %rbx, %r15
addq $0x8, %r15
movl $0x4, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4420
cmpl $0x4, %eax
jne 0x752d
cmpl $0x0, 0x1c(%r14)
setne (%rbx)
jne 0x7530
movl (%r15), %edi
testq %rdi, %rdi
je 0x753e
shlq $0x3, %rdi
callq 0x4600
cmpl $0x0, 0x8(%rbx)
movq %rax, 0x10(%rbx)
je 0x7530
xorl %r15d, %r15d
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x46f0
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movl 0x8(%rbx), %eax
cmpq %rax, %r15
jb 0x7508
jmp 0x7530
xorl %ebx, %ebx
jmp 0x7530
movb $0x1, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, 0x10(%rbx)
jmp 0x7530
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_parser.c
// Function: dx_annotationitem
DexAnnotationItem* dx_annotationitem(ByteStream* bs, uint32_t offset) {
  DexAnnotationItem* res;
  int check;

  if (bs == NULL) return NULL;

  DX_ALLOC(DexAnnotationItem,res);

  bsseek(bs,offset);

  check  = bsread(bs,(uint8_t*) &(res->visibility),sizeof(uint8_t));

  res->annotation = dx_encodedannotation(bs,bs->offset);

  res->meta.corrupted = (check != sizeof(uint8_t) || bs->exhausted);
  
  return res;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x75a9
movl %esi, %ebp
movq %rdi, %r14
movl $0x18, %edi
callq 0x4600
movq %rax, %rbx
movl %ebp, 0x4(%rax)
movb $0x0, (%rax)
movq %r14, %rdi
movl %ebp, %esi
callq 0x4410
leaq 0x8(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x4420
movl %eax, %ebp
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x4150
movq %rax, 0x10(%rbx)
movb $0x1, %al
cmpl $0x1, %ebp
jne 0x75a5
cmpl $0x0, 0x1c(%r14)
setne %al
movb %al, (%rbx)
jmp 0x75ab
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_string.c
// Function: dx_string_find_index
uint32_t dx_string_find_index(Dex* dx, char* str) {
  unsigned int i;
  int ret;

  if (dx == NULL || str == NULL) return -1;

  for (i=0; i<dx->header->string_ids_size; i++) {
    ret = strncmp(str, (char *)dx->string_data_list[i]->data, strlen((char *)dx->string_data_list[i]->data));

    if (ret == 0) // string already exists
      return -1;
    else if (ret < 0)
      return i;
  }

  return dx->header->string_ids_size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jne 0x84e7
movq (%rdi), %rax
movl 0x40(%rax), %r12d
testq %r12, %r12
je 0x84e0
movq %rsi, %r14
movq 0x40(%rdi), %rbp
xorl %r13d, %r13d
movq (%rbp,%r13,8), %rax
movq 0x18(%rax), %r15
movq %r15, %rdi
callq 0x41c0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x40a0
testl %eax, %eax
je 0x84e7
js 0x84e4
incq %r13
cmpq %r13, %r12
jne 0x84ae
movl %r12d, %ebx
jmp 0x84e7
xorl %ebx, %ebx
jmp 0x84e7
movl %r13d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_string.c
// Function: dx_string_add
void dx_string_add(Dex* dx, char* str) {
  uint32_t index;

  if (dx == NULL || str == NULL) return;

  index = dx_string_find_index(dx,str);

  dx_string_add_stringid(dx,index);
  dx_string_add_stringdata(dx,index,str);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x8819
retq
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x47f0
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
callq 0x42b0
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x4490
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: add_shift
void add_shift(dx_shift* shift, uint32_t base, int32_t delta) {
  dx_shift* next;
  dx_shift* last;

  printf("Shift Added.\n");

  if (shift == NULL) return;

  next = (dx_shift*) malloc_s(sizeof(dx_shift));

  next->base = base;
  next->delta = delta;
  next->next = NULL;
  
  last = shift;
  while (last->next != NULL) last = last->next;
  
  last->next = next;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x198e(%rip), %rdi      # 0xa1e9
callq 0x40e0
testq %rbx, %rbx
je 0x888d
movl $0x10, %edi
callq 0x4600
movl %r14d, (%rax)
movl %ebp, 0x4(%rax)
movq $0x0, 0x8(%rax)
movq %rbx, %rcx
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x887d
movq %rax, 0x8(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_header
void dxo_header(DexHeaderItem* obj, dx_shift* shift) {
  UPDATE(obj->meta.offset);

  UPDATE(obj->link_off);
  UPDATE(obj->map_off);
  UPDATE(obj->string_ids_off);
  UPDATE(obj->type_ids_off);
  UPDATE(obj->proto_ids_off);
  UPDATE(obj->field_ids_off);
  UPDATE(obj->method_ids_off);
  UPDATE(obj->class_defs_off);
  UPDATE(obj->data_off);
}

// Assembly:
movl 0x4(%rdi), %ecx
movl (%rsi), %eax
cmpl %eax, %ecx
jb 0x88a1
addl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
movl 0x38(%rdi), %ecx
cmpl %eax, %ecx
jb 0x88ae
addl 0x4(%rsi), %ecx
movl %ecx, 0x38(%rdi)
movl 0x3c(%rdi), %ecx
cmpl %eax, %ecx
jb 0x88bb
addl 0x4(%rsi), %ecx
movl %ecx, 0x3c(%rdi)
movl 0x44(%rdi), %ecx
cmpl %eax, %ecx
jb 0x88c8
addl 0x4(%rsi), %ecx
movl %ecx, 0x44(%rdi)
movl 0x4c(%rdi), %ecx
cmpl %eax, %ecx
jb 0x88d5
addl 0x4(%rsi), %ecx
movl %ecx, 0x4c(%rdi)
movl 0x54(%rdi), %ecx
cmpl %eax, %ecx
jb 0x88e2
addl 0x4(%rsi), %ecx
movl %ecx, 0x54(%rdi)
movl 0x5c(%rdi), %ecx
cmpl %eax, %ecx
jb 0x88ef
addl 0x4(%rsi), %ecx
movl %ecx, 0x5c(%rdi)
movl 0x64(%rdi), %ecx
cmpl %eax, %ecx
jb 0x88fc
addl 0x4(%rsi), %ecx
movl %ecx, 0x64(%rdi)
movl 0x6c(%rdi), %ecx
cmpl %eax, %ecx
jb 0x8909
addl 0x4(%rsi), %ecx
movl %ecx, 0x6c(%rdi)
movl 0x74(%rdi), %ecx
cmpl %eax, %ecx
jb 0x8916
addl 0x4(%rsi), %ecx
movl %ecx, 0x74(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_classdef
void dxo_classdef(DexClassDefItem* obj, dx_shift* shift) {
  UPDATE(obj->meta.offset);

  UPDATE(obj->interfaces_off);
  UPDATE(obj->annotations_off);
  UPDATE(obj->class_data_off);
  UPDATE(obj->static_values_off);
}

// Assembly:
movl 0x4(%rdi), %ecx
movl (%rsi), %eax
cmpl %eax, %ecx
jb 0x898a
addl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
movl 0x14(%rdi), %ecx
cmpl %eax, %ecx
jb 0x8997
addl 0x4(%rsi), %ecx
movl %ecx, 0x14(%rdi)
movl 0x1c(%rdi), %ecx
cmpl %eax, %ecx
jb 0x89a4
addl 0x4(%rsi), %ecx
movl %ecx, 0x1c(%rdi)
movl 0x20(%rdi), %ecx
cmpl %eax, %ecx
jb 0x89b1
addl 0x4(%rsi), %ecx
movl %ecx, 0x20(%rdi)
movl 0x24(%rdi), %ecx
cmpl %eax, %ecx
jb 0x89be
addl 0x4(%rsi), %ecx
movl %ecx, 0x24(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_encodedmethod
void dxo_encodedmethod(DexEncodedMethodItem* obj, dx_shift* shift) {
  size_t old_size;

  UPDATE(obj->meta.offset);
  
  old_size = obj->code_off.size;
  
  UPDATE_ULEB(obj->code_off);

  if (obj->code_off.size != old_size)
    add_shift(shift,obj->meta.offset + 1,obj->code_off.size - old_size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %eax
cmpl (%rsi), %eax
jb 0x89f6
addl 0x4(%rbx), %eax
movl %eax, 0x4(%r14)
movl 0x28(%r14), %ebp
movq 0x20(%r14), %rdi
movl %ebp, %esi
callq 0x4170
cmpl (%rbx), %eax
jb 0x8a27
leaq 0x20(%r14), %r15
movq 0x20(%r14), %rdi
movl 0x28(%r14), %esi
callq 0x4170
addl 0x4(%rbx), %eax
movq %r15, %rdi
movl %eax, %esi
callq 0x4450
movl 0x28(%r14), %edx
subl %ebp, %edx
jne 0x8a3a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%r14), %esi
incl %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4230
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_classdata
void dxo_classdata(DexClassDataItem* obj, dx_shift* shift) {
  unsigned int i;

  UPDATE(obj->meta.offset);

  for (i=0; i<ul128toui(obj->static_fields_size); i++)
    dxo_encodedfield(obj->static_fields[i],shift);

  for (i=0; i<ul128toui(obj->instance_fields_size); i++)
    dxo_encodedfield(obj->instance_fields[i],shift);

  for (i=0; i<ul128toui(obj->direct_methods_size); i++)
    dxo_encodedmethod(obj->direct_methods[i],shift);

  for (i=0; i<ul128toui(obj->virtual_methods_size); i++)
    dxo_encodedmethod(obj->virtual_methods[i],shift);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %eax
cmpl (%rsi), %eax
jb 0x8a6b
addl 0x4(%rbx), %eax
movl %eax, 0x4(%r14)
movq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x4170
testl %eax, %eax
je 0x8aab
xorl %r15d, %r15d
movq 0x38(%r14), %rax
movq (%rax,%r15,8), %rax
movl 0x4(%rax), %ecx
cmpl (%rbx), %ecx
jb 0x8a94
addl 0x4(%rbx), %ecx
movl %ecx, 0x4(%rax)
incq %r15
movq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x4170
movl %eax, %eax
cmpq %rax, %r15
jb 0x8a7f
movq 0x14(%r14), %rdi
movl 0x1c(%r14), %esi
callq 0x4170
testl %eax, %eax
je 0x8aeb
xorl %r15d, %r15d
movq 0x40(%r14), %rax
movq (%rax,%r15,8), %rax
movl 0x4(%rax), %ecx
cmpl (%rbx), %ecx
jb 0x8ad4
addl 0x4(%rbx), %ecx
movl %ecx, 0x4(%rax)
incq %r15
movq 0x14(%r14), %rdi
movl 0x1c(%r14), %esi
callq 0x4170
movl %eax, %eax
cmpq %rax, %r15
jb 0x8abf
movq 0x20(%r14), %rdi
movl 0x28(%r14), %esi
callq 0x4170
testl %eax, %eax
je 0x8b26
xorl %r15d, %r15d
movq 0x48(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x46b0
incq %r15
movq 0x20(%r14), %rdi
movl 0x28(%r14), %esi
callq 0x4170
movl %eax, %eax
cmpq %rax, %r15
jb 0x8aff
movq 0x2c(%r14), %rdi
movl 0x34(%r14), %esi
callq 0x4170
testl %eax, %eax
je 0x8b61
xorl %r15d, %r15d
movq 0x50(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x46b0
incq %r15
movq 0x2c(%r14), %rdi
movl 0x34(%r14), %esi
callq 0x4170
movl %eax, %eax
cmpq %rax, %r15
jb 0x8b3a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_typelist
void dxo_typelist(DexTypeList* obj, dx_shift* shift) {
  unsigned int i;

  UPDATE(obj->meta.offset);

  for (i=0; i<obj->size; i++)
    dxo_typeitem(obj->list[i],shift);
}

// Assembly:
movl 0x4(%rdi), %ecx
movl (%rsi), %eax
cmpl %eax, %ecx
jb 0x8b84
addl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
movl 0x8(%rdi), %ecx
testq %rcx, %rcx
je 0x8baf
movq 0x10(%rdi), %rdx
xorl %edi, %edi
movq (%rdx,%rdi,8), %r8
movl 0x4(%r8), %r9d
cmpl %eax, %r9d
jb 0x8ba7
addl 0x4(%rsi), %r9d
movl %r9d, 0x4(%r8)
incq %rdi
cmpq %rdi, %rcx
jne 0x8b92
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_encodedcatchhandler
void dxo_encodedcatchhandler(DexEncodedCatchHandler* obj, dx_shift* shift) {
  int i;

  UPDATE(obj->meta.offset);

  for (i=0; i<abs(sl128toi(obj->size)); i++)
    dxo_encodedtypeaddrpair(obj->handlers[i],shift);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %eax
cmpl (%rsi), %eax
jb 0x8be5
addl 0x4(%rbx), %eax
movl %eax, 0x4(%r14)
movq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x44e0
testl %eax, %eax
je 0x8c2a
xorl %r15d, %r15d
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rax
movl 0x4(%rax), %ecx
cmpl (%rbx), %ecx
jb 0x8c0e
addl 0x4(%rbx), %ecx
movl %ecx, 0x4(%rax)
incq %r15
movq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x44e0
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpq %rcx, %r15
jb 0x8bf9
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_encodedcatchhandlerlist
void dxo_encodedcatchhandlerlist(DexEncodedCatchHandlerList* obj, dx_shift* shift) {
  unsigned int i;

  UPDATE(obj->meta.offset);

  for (i=0; i<ul128toui(obj->size); i++)
    dxo_encodedcatchhandler(obj->list[i],shift);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %eax
cmpl (%rsi), %eax
jb 0x8c49
addl 0x4(%rbx), %eax
movl %eax, 0x4(%r14)
movq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x4170
testl %eax, %eax
je 0x8c84
xorl %r15d, %r15d
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x44f0
incq %r15
movq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x4170
movl %eax, %eax
cmpq %rax, %r15
jb 0x8c5d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_codeitem
void dxo_codeitem(DexCodeItem* obj, dx_shift* shift) {
  unsigned int i;

  UPDATE(obj->meta.offset);

  UPDATE(obj->debug_info_off);

  if (obj->tries_size > 0) {
    for (i=0; i<obj->tries_size; i++)
      dxo_tryitem(obj->tries[i],shift);

    dxo_encodedcatchhandlerlist(obj->handlers,shift);    
  }
}

// Assembly:
movl 0x4(%rdi), %ecx
movl (%rsi), %eax
cmpl %eax, %ecx
jb 0x8c99
addl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
movl 0x10(%rdi), %ecx
cmpl %eax, %ecx
jb 0x8ca6
addl 0x4(%rsi), %ecx
movl %ecx, 0x10(%rdi)
movzwl 0xe(%rdi), %ecx
testq %rcx, %rcx
je 0x8cdc
movq 0x28(%rdi), %rdx
xorl %r8d, %r8d
movq (%rdx,%r8,8), %r9
movl 0x4(%r9), %r10d
cmpl %eax, %r10d
jb 0x8ccb
addl 0x4(%rsi), %r10d
movl %r10d, 0x4(%r9)
incq %r8
cmpq %r8, %rcx
jne 0x8cb6
movq 0x30(%rdi), %rdi
jmp 0x4070
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_maplist
void dxo_maplist(DexMapList* obj, dx_shift* shift) {
  unsigned int i;

  UPDATE(obj->meta.offset);

  for (i=0; i<obj->size; i++)
    dxo_mapitem(obj->list[i],shift);
}

// Assembly:
movl 0x4(%rdi), %ecx
movl (%rsi), %eax
cmpl %eax, %ecx
jb 0x8d17
addl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
movl 0x8(%rdi), %ecx
testq %rcx, %rcx
je 0x8d53
movq 0x10(%rdi), %rdx
xorl %edi, %edi
movq (%rdx,%rdi,8), %r8
movl 0x4(%r8), %r9d
cmpl %eax, %r9d
jb 0x8d3a
addl 0x4(%rsi), %r9d
movl %r9d, 0x4(%r8)
movl 0x10(%r8), %r9d
cmpl %eax, %r9d
jb 0x8d4b
addl 0x4(%rsi), %r9d
movl %r9d, 0x10(%r8)
incq %rdi
cmpq %rdi, %rcx
jne 0x8d25
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_encodedarray
void dxo_encodedarray(DexEncodedArray* obj, dx_shift* shift) {
  unsigned int i;
  
  UPDATE(obj->meta.offset);

  for (i=0; i<ul128toui(obj->size); i++)
    dxo_encodedvalue(obj->values[i],shift);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %eax
cmpl (%rsi), %eax
jb 0x8d9e
addl 0x4(%rbx), %eax
movl %eax, 0x4(%r14)
movq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x4170
testl %eax, %eax
je 0x8dd9
xorl %r15d, %r15d
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x4180
incq %r15
movq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x4170
movl %eax, %eax
cmpq %rax, %r15
jb 0x8db2
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_encodedannotation
void dxo_encodedannotation(DexEncodedAnnotation* obj, dx_shift* shift) {
  unsigned int i;

  UPDATE(obj->meta.offset);

  for (i=0; i<ul128toui(obj->size); i++)
    dxo_annotationelement(obj->elements[i],shift);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %eax
cmpl (%rsi), %eax
jb 0x8df8
addl 0x4(%rbx), %eax
movl %eax, 0x4(%r14)
movq 0x14(%r14), %rdi
movl 0x1c(%r14), %esi
callq 0x4170
testl %eax, %eax
je 0x8e44
xorl %r15d, %r15d
movq 0x20(%r14), %rax
movq (%rax,%r15,8), %rax
movl 0x4(%rax), %ecx
cmpl (%rbx), %ecx
jb 0x8e21
addl 0x4(%rbx), %ecx
movl %ecx, 0x4(%rax)
movq 0x18(%rax), %rdi
movq %rbx, %rsi
callq 0x4180
incq %r15
movq 0x14(%r14), %rdi
movl 0x1c(%r14), %esi
callq 0x4170
movl %eax, %eax
cmpq %rax, %r15
jb 0x8e0c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_annotationdirectoryitem
void dxo_annotationdirectoryitem(DexAnnotationDirectoryItem* obj, dx_shift* shift) {
  unsigned int i;

  UPDATE(obj->meta.offset);

  UPDATE(obj->class_annotations_off);

  for (i=0; i<obj->fields_size; i++)
    dxo_fieldannotation(obj->field_annotations[i],shift);

  for (i=0; i<obj->annotated_methods_size; i++)
    dxo_methodannotation(obj->method_annotations[i],shift);
  
  for (i=0; i<obj->annotated_parameters_size; i++)
    dxo_parameterannotation(obj->parameter_annotations[i],shift);
}

// Assembly:
movl 0x4(%rdi), %ecx
movl (%rsi), %eax
cmpl %eax, %ecx
jb 0x8ec6
addl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
movl 0x8(%rdi), %ecx
cmpl %eax, %ecx
jb 0x8ed3
addl 0x4(%rsi), %ecx
movl %ecx, 0x8(%rdi)
movl 0xc(%rdi), %ecx
testq %rcx, %rcx
je 0x8f10
movq 0x18(%rdi), %rdx
xorl %r8d, %r8d
movq (%rdx,%r8,8), %r9
movl 0x4(%r9), %r10d
cmpl %eax, %r10d
jb 0x8ef7
addl 0x4(%rsi), %r10d
movl %r10d, 0x4(%r9)
movl 0xc(%r9), %r10d
cmpl %eax, %r10d
jb 0x8f08
addl 0x4(%rsi), %r10d
movl %r10d, 0xc(%r9)
incq %r8
cmpq %r8, %rcx
jne 0x8ee2
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x8f4d
movq 0x20(%rdi), %rdx
xorl %r8d, %r8d
movq (%rdx,%r8,8), %r9
movl 0x4(%r9), %r10d
cmpl %eax, %r10d
jb 0x8f34
addl 0x4(%rsi), %r10d
movl %r10d, 0x4(%r9)
movl 0xc(%r9), %r10d
cmpl %eax, %r10d
jb 0x8f45
addl 0x4(%rsi), %r10d
movl %r10d, 0xc(%r9)
incq %r8
cmpq %r8, %rcx
jne 0x8f1f
movl 0x14(%rdi), %ecx
testq %rcx, %rcx
je 0x8f89
movq 0x28(%rdi), %rdx
xorl %edi, %edi
movq (%rdx,%rdi,8), %r8
movl 0x4(%r8), %r9d
cmpl %eax, %r9d
jb 0x8f70
addl 0x4(%rsi), %r9d
movl %r9d, 0x4(%r8)
movl 0xc(%r8), %r9d
cmpl %eax, %r9d
jb 0x8f81
addl 0x4(%rsi), %r9d
movl %r9d, 0xc(%r8)
incq %rdi
cmpq %rdi, %rcx
jne 0x8f5b
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_annotationsetreflist
void dxo_annotationsetreflist(DexAnnotationSetRefList* obj, dx_shift* shift) {
  unsigned int i;

  UPDATE(obj->meta.offset);

  for (i=0; i<obj->size; i++)
    dxo_annotationsetrefitem(obj->list[i],shift);
}

// Assembly:
movl 0x4(%rdi), %ecx
movl (%rsi), %eax
cmpl %eax, %ecx
jb 0x8fb6
addl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
movl 0x8(%rdi), %ecx
testq %rcx, %rcx
je 0x8ff2
movq 0x10(%rdi), %rdx
xorl %edi, %edi
movq (%rdx,%rdi,8), %r8
movl 0x4(%r8), %r9d
cmpl %eax, %r9d
jb 0x8fd9
addl 0x4(%rsi), %r9d
movl %r9d, 0x4(%r8)
movl 0x8(%r8), %r9d
cmpl %eax, %r9d
jb 0x8fea
addl 0x4(%rsi), %r9d
movl %r9d, 0x8(%r8)
incq %rdi
cmpq %rdi, %rcx
jne 0x8fc4
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_offset.c
// Function: dxo_annotationsetitem
void dxo_annotationsetitem(DexAnnotationSetItem* obj, dx_shift* shift) {
  unsigned int i;

  UPDATE(obj->meta.offset);

  for (i=0; i<obj->size; i++)
    dxo_annotationoffitem(obj->entries[i],shift);
}

// Assembly:
movl 0x4(%rdi), %ecx
movl (%rsi), %eax
cmpl %eax, %ecx
jb 0x901f
addl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
movl 0x8(%rdi), %ecx
testq %rcx, %rcx
je 0x905b
movq 0x10(%rdi), %rdx
xorl %edi, %edi
movq (%rdx,%rdi,8), %r8
movl 0x4(%r8), %r9d
cmpl %eax, %r9d
jb 0x9042
addl 0x4(%rsi), %r9d
movl %r9d, 0x4(%r8)
movl 0x8(%r8), %r9d
cmpl %eax, %r9d
jb 0x9053
addl 0x4(%rsi), %r9d
movl %r9d, 0x8(%r8)
incq %rdi
cmpq %rdi, %rcx
jne 0x902d
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_stringid.c
// Function: dxsi_debuginfo
void dxsi_debuginfo(DexDebugInfo* obj, dx_shift* shift) {
  unsigned int i;
  size_t old_size;

  for (i=0; i<ul128toui(obj->parameters_size); i++) {
    old_size = obj->parameter_names[i].size;

    UPDATE_ULEBP1(obj->parameter_names[i]);
    
    if (obj->parameter_names[i].size != old_size)
      add_shift(shift,obj->meta.offset + 1,obj->parameter_names[i].size - old_size);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x14(%rdi), %rdi
movl 0x1c(%r14), %esi
callq 0x4170
testl %eax, %eax
je 0x9537
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x20(%r14), %rax
movl 0x8(%rax,%r12), %ebp
movq (%rax,%r12), %rdi
movl %ebp, %esi
callq 0x44a0
cmpl (%rbx), %eax
jl 0x9501
movq 0x20(%r14), %rax
leaq (%rax,%r12), %r15
movq (%rax,%r12), %rdi
movl 0x8(%rax,%r12), %esi
callq 0x44a0
addl 0x4(%rbx), %eax
movq %r15, %rdi
movl %eax, %esi
callq 0x45f0
movq 0x20(%r14), %rax
movl 0x8(%rax,%r12), %edx
subl %ebp, %edx
je 0x951c
movl 0x4(%r14), %esi
incl %esi
movq %rbx, %rdi
callq 0x4230
incq %r13
movq 0x14(%r14), %rdi
movl 0x1c(%r14), %esi
callq 0x4170
movl %eax, %eax
addq $0xc, %r12
cmpq %rax, %r13
jb 0x94c6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_stringid.c
// Function: dxsi_encodedvalue
void dxsi_encodedvalue(DexEncodedValue* obj, dx_shift* shift) {
  uint8_t value_type;

  value_type = (obj->argtype & 0x1f);
	       
  switch (value_type) {
  case 0x17:
    UPDATE(*((uint32_t*)obj->value));
    break;
  case 0x1C:
    dxsi_encodedarray((DexEncodedArray*) obj->value,shift);
    break;
  case 0x1d:
    dxsi_encodedannotation((DexEncodedAnnotation*)obj->value,shift);
    break;
  default:
    break;
  }
}

// Assembly:
movzbl 0x8(%rdi), %eax
andl $0x1f, %eax
cmpl $0x1d, %eax
je 0x9575
cmpl $0x1c, %eax
je 0x956c
cmpl $0x17, %eax
jne 0x956b
movq 0x10(%rdi), %rax
movl (%rax), %ecx
cmpl (%rsi), %ecx
jb 0x956b
addl 0x4(%rsi), %ecx
movl %ecx, (%rax)
retq
movq 0x10(%rdi), %rdi
jmp 0x42f0
movq 0x10(%rdi), %rdi
jmp 0x46d0
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/dex_stringid.c
// Function: dxsi_annotationelement
void dxsi_annotationelement(DexAnnotationElement* obj, dx_shift* shift) {
  size_t old_size;
 
  old_size = obj->name_idx.size;

  UPDATE_ULEB(obj->name_idx);
  
  if (obj->name_idx.size != old_size)
    add_shift(shift,obj->meta.offset + 1,obj->name_idx.size - old_size);

  dxsi_encodedvalue(obj->value,shift);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rdi), %ebp
movq 0x8(%rdi), %rdi
movl %ebp, %esi
callq 0x4170
cmpl (%rbx), %eax
jb 0x9653
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x4170
addl 0x4(%rbx), %eax
movq %r15, %rdi
movl %eax, %esi
callq 0x4450
movl 0x10(%r14), %edx
subl %ebp, %edx
je 0x9669
movl 0x4(%r14), %esi
incl %esi
movq %rbx, %rdi
callq 0x4230
movq 0x18(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4680
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/leb128.c
// Function: l128size
unsigned int l128size(ByteStream* bs) {
  int32_t offset;
  unsigned int len = 0;
  uint8_t cbyte = 0x0;

  if (bs == NULL) return 0;

  offset = bs->offset;

  bsread(bs,&cbyte,1);

  if (!bs->exhausted) {
    len = 1;

    while (!bs->exhausted && len < 5 && (cbyte & 0x80) != 0x0) {
      len++;
      bsread(bs,&cbyte,1);
    }      
  }  
  
  bsseek(bs,offset);  

  return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movb $0x0, 0xf(%rsp)
testq %rdi, %rdi
je 0x9903
movq %rdi, %rbx
movl 0x18(%rdi), %ebp
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
callq 0x4420
xorl %r14d, %r14d
cmpl $0x0, 0x1c(%rbx)
jne 0x98f7
movl $0x1, %r14d
cmpb $0x0, 0xf(%rsp)
jns 0x98f7
movl $0x1, %r12d
leaq 0xf(%rsp), %r15
leal 0x1(%r12), %r14d
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4420
cmpl $0x0, 0x1c(%rbx)
jne 0x98f7
cmpl $0x3, %r12d
ja 0x98f7
cmpb $0x0, 0xf(%rsp)
movl %r14d, %r12d
js 0x98cc
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4410
jmp 0x9906
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/leb128.c
// Function: l128read
int l128read(ByteStream* bs, leb128_t* leb) {
  unsigned int ret;

  if (bs == NULL || leb == NULL) return -1;

  leb->size = l128size(bs);

  ret = bsread(bs,leb->data,leb->size);

  return ret != leb->size;
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x995b
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4260
movl %eax, 0x8(%rbx)
movl %eax, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4420
movl %eax, %ecx
xorl %eax, %eax
cmpl 0x8(%rbx), %ecx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/leb128.c
// Function: ul128toui
uint32_t ul128toui(leb128_t uleb) {
  uint32_t val = 0;
  int i;
  
  for (i=uleb.size-1; i>=0; i--) {
    val = val * 128 + (uleb.data[i] & 0x7f);
  }  

  return val;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x8(%rsp)
decl %esi
js 0x9a0e
movl %esi, %ecx
xorl %eax, %eax
shll $0x7, %eax
movzbl -0x10(%rsp,%rcx), %edx
andl $0x7f, %edx
orl %edx, %eax
addq $-0x1, %rcx
jb 0x99fa
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/leb128.c
// Function: sl128toi
int32_t sl128toi(leb128_t sleb) {
  int32_t val = 0;
  
  val = ul128toui(sleb);

  if ((sleb.size != 5) && (sleb.data[sleb.size-1] & 0x40) != 0) {
    val = val | ~((1 << (sleb.size*7))-1);
  }

  return val;
}

// Assembly:
movq %rdi, -0x20(%rsp)
movl %esi, -0x18(%rsp)
movq %rdi, -0x10(%rsp)
movl %esi, -0x8(%rsp)
movl %esi, %eax
decl %eax
js 0x9a7a
movl %eax, %ecx
xorl %eax, %eax
movq %rcx, %rdx
movl %eax, %edi
shll $0x7, %edi
movzbl -0x10(%rsp,%rdx), %eax
andl $0x7f, %eax
orl %edi, %eax
addq $-0x1, %rdx
jb 0x9a5f
cmpl $0x5, %esi
jne 0x9a7e
retq
movl %eax, %ecx
xorl %eax, %eax
testb $0x40, -0x20(%rsp,%rcx)
je 0x9a79
leal (,%rsi,8), %ecx
subl %esi, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
orl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/leb128.c
// Function: uitoul128
void uitoul128(leb128_t* leb, uint32_t num) {
  unsigned int i;

  for (i=0; i<5; i++) {
    if (i == 4)
      leb->data[i] = num & 0x4f;
    else
      leb->data[i] = num & 0x7f;

    num /= 128;
    
    if (num == 0) break;

    leb->data[i] |= 0x80;
  }

  leb->size = i+1;
}

// Assembly:
xorl %eax, %eax
movl %esi, %ecx
cmpq $0x4, %rax
jne 0x9aaa
andb $0x4f, %cl
movb %cl, 0x4(%rdi)
jmp 0x9ab0
andb $0x7f, %cl
movb %cl, (%rdi,%rax)
cmpl $0x80, %esi
jb 0x9acf
orb $-0x80, (%rdi,%rax)
shrl $0x7, %esi
incq %rax
cmpq $0x5, %rax
jne 0x9a9a
movl $0x6, %eax
jmp 0x9ad1
incl %eax
movl %eax, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/leb128.c
// Function: itosl128
void itosl128(leb128_t* leb, int32_t num) {
  unsigned int i;

  leb->data[0] = ((num >> 00) & 0x7f) | 0x80;
  leb->data[1] = ((num >> 07) & 0x7f) | 0x80;
  leb->data[2] = ((num >> 14) & 0x7f) | 0x80;
  leb->data[3] = ((num >> 21) & 0x7f) | 0x80;
  leb->data[4] = ((num >> 28) & 0x4f) | 0x00;

  leb->size = 5;

  if (leb->data[4] == 0x00 || leb->data[4] == 0x4f) {
    leb->size--;

    for (i=3; i>0; i--) {
      if (leb->data[i] == 0x80 || leb->data[i] == 0xff)
	leb->size--;
      else 
	break;
    }
  }

  if (num > 0 && (leb->data[leb->size-1] & 0x40) != 0x0) {
    leb->size++;
  } 

  if (num < 0 && (leb->data[leb->size-1] & 0x40) == 0x0) {
    leb->size++;
  } 

  leb->data[leb->size-1] &= 0x7f;
}

// Assembly:
movl %esi, %eax
orb $-0x80, %al
movb %al, (%rdi)
movl %esi, %eax
shrl $0x7, %eax
orb $-0x80, %al
movb %al, 0x1(%rdi)
movl %esi, %eax
shrl $0xe, %eax
orb $-0x80, %al
movb %al, 0x2(%rdi)
movl %esi, %eax
shrl $0x15, %eax
orb $-0x80, %al
movb %al, 0x3(%rdi)
movl %esi, %ecx
sarl $0x1c, %ecx
movl %ecx, %eax
andb $0x4f, %al
movb %al, 0x4(%rdi)
movl $0x5, 0x8(%rdi)
andl $0x4f, %ecx
cmpl $0x4f, %ecx
je 0x9b5c
movl $0x5, %eax
testl %ecx, %ecx
jne 0x9b8b
movl $0x4, 0x8(%rdi)
movl $0x3, %ecx
movl $0x4, %eax
movzbl (%rdi,%rcx), %edx
cmpl $0xff, %edx
je 0x9b81
cmpl $0x80, %edx
jne 0x9b8b
decl %eax
movl %eax, 0x8(%rdi)
decq %rcx
jne 0x9b6d
testl %esi, %esi
jle 0x9b9f
leal -0x1(%rax), %ecx
testb $0x40, (%rdi,%rcx)
je 0x9baa
incl %eax
movl %eax, 0x8(%rdi)
jmp 0x9baa
jns 0x9baa
leal -0x1(%rax), %ecx
testb $0x40, (%rdi,%rcx)
je 0x9b98
decl %eax
andb $0x7f, (%rdi,%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/rchiossi[P]dexterity/lib/malloc_s.c
// Function: malloc_s
void *malloc_s(size_t size) {
	if (!size)
		return NULL;

	void *new_mem = malloc(size);

	if (!new_mem) {
		fprintf(stderr, "fatal: memory exhausted (malloc of %zu bytes)\n", size);
		exit(-1);
	}

	return new_mem;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x9bcf
movq %rdi, %rbx
callq 0x44b0
testq %rax, %rax
jne 0x9bd1
movq %rbx, %rdi
callq 0x4850
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/comfies[P]custard/src/vector.c
// Function: construct_vector
vector_t *construct_vector() {
    vector_t *vector = (vector_t*)calloc(1, sizeof(vector_t));
    vector->memory = 1;
    vector->size = 0;
    vector->elements = calloc(1, sizeof(void*));
    vector->remaining = 0;

    return vector;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x3340
movq %rax, %rbx
movl $0x1, 0x8(%rax)
movl $0x1, %edi
movl $0x8, %esi
callq 0x3340
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/comfies[P]custard/src/vector.c
// Function: vector_iterator
void *vector_iterator(vector_t *vector) {
    if (!vector->remaining) {
        vector->remaining = vector->size;
        return NULL;
    }

    unsigned int index = (vector->size - vector->remaining);
    vector->remaining--;

    return get_from_vector(vector, index);
}

// Assembly:
movl 0xc(%rdi), %eax
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x3865
leal -0x1(%rcx), %edx
movl %edx, 0x10(%rdi)
subl %ecx, %eax
jb 0x3868
movq (%rdi), %rcx
movq (%rcx,%rax,8), %rax
retq
movl %eax, 0x10(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/comfies[P]custard/src/vector.c
// Function: pull_from_vector
void pull_from_vector(vector_t *vector, unsigned int index) {
    if (index >= vector->size)
        return;

    for (; index < vector->size; index++)
        vector->elements[index] = vector->elements[index + 1];

    vector->elements[vector->size--] = NULL;
    vector->remaining--;

    if ((vector->size * 2) == vector->memory) {
        vector->memory /= 2;
        vector->elements = realloc(vector->elements,
            sizeof(void *) * (vector->memory + 1));
    }
}

// Assembly:
movl 0xc(%rdi), %eax
cmpl %esi, %eax
jbe 0x392d
pushq %rbx
movq %rdi, %rbx
movl %esi, %ecx
movq (%rbx), %rdx
movq 0x8(%rdx,%rcx,8), %rsi
movq %rsi, (%rdx,%rcx,8)
leaq 0x1(%rcx), %rdx
movq %rdx, %rcx
cmpq %rdx, %rax
jne 0x38d8
movq (%rbx), %rdx
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rbx)
movq $0x0, (%rdx,%rax,8)
decl 0x10(%rbx)
leal -0x2(,%rax,2), %eax
cmpl 0x8(%rbx), %eax
jne 0x392c
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, 0x8(%rbx)
movq (%rbx), %rdi
leaq 0x8(,%rcx,8), %rsi
callq 0x34a0
movq %rax, (%rbx)
popq %rbx
retq