LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/umbrant[P]Non-blocking-Buffers/nbb.c
// Function: nbb_set_cb_new_data
void nbb_set_cb_new_data(const char* owner, cb_new_data_func func)
{
  int i;

  assert(owner != NULL && func != NULL);

  for(i = 1;i < SERVICE_MAX_CHANNELS;i++) {
    if(!channel_list[i].in_use) {
      continue;
    }

    if(channel_list[i].owner && !strcmp(owner, channel_list[i].owner)) {
      channel_list[i].new_data = func;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2da0
cmpq $0x0, -0x10(%rbp)
je 0x2da0
jmp 0x2dbf
leaq 0x17b0(%rip), %rdi      # 0x4557
leaq 0x13fb(%rip), %rsi      # 0x41a9
movl $0x109, %edx            # imm = 0x109
leaq 0x182d(%rip), %rcx      # 0x45e7
callq 0x10c0
movl $0x1, -0x14(%rbp)
cmpl $0xf, -0x14(%rbp)
jge 0x2e51
movslq -0x14(%rbp), %rcx
leaq 0x4365(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x50(%rax)
jne 0x2dea
jmp 0x2e43
movslq -0x14(%rbp), %rcx
leaq 0x434b(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x30(%rax)
je 0x2e41
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x432e(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x30(%rax), %rsi
callq 0x1100
cmpl $0x0, %eax
jne 0x2e41
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
leaq 0x430a(%rip), %rax      # 0x7140
imulq $0x58, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x40(%rax)
jmp 0x2e43
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2dc6
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/umbrant[P]Non-blocking-Buffers/nbb.c
// Function: nbb_flush_shm
void nbb_flush_shm(int slot, char* array_to_flush, int size)
{
  assert(slot >= 0 && slot < SERVICE_MAX_CHANNELS);
  assert(array_to_flush != NULL && size >= 0);

  if (size == 0)
    return;

  delay_buffer_t* buffer = &(delay_buffers[slot]);
  int new_size = buffer->len + size;

  // Grow the buffer if exceeding current capacity
  if (new_size > buffer->capacity) {
    // Initial capacity (2 * MAX_MSG_LEN)
    if (buffer->capacity == 0) {
      buffer->capacity = MAX_MSG_LEN;
    }
    buffer->content = (char *) realloc(buffer->content, 2 * buffer->capacity);
    buffer->capacity = 2 * buffer->capacity;
  }

  // Append new data to the end (or beginning if it's the first flush)
  memcpy(buffer->content + buffer->len, array_to_flush, size);
  buffer->len = new_size;

  //printf("** Intermediate buffer content: '%.*s' (%d bytes)\n",
  //       buffer->len, buffer->content, buffer->len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x2e80
cmpl $0xf, -0x4(%rbp)
jge 0x2e80
jmp 0x2e9f
leaq 0x1a5a(%rip), %rdi      # 0x48e1
leaq 0x131b(%rip), %rsi      # 0x41a9
movl $0x23c, %edx            # imm = 0x23C
leaq 0x1ac0(%rip), %rcx      # 0x495a
callq 0x10c0
cmpq $0x0, -0x10(%rbp)
je 0x2eae
cmpl $0x0, -0x14(%rbp)
jl 0x2eae
jmp 0x2ecd
leaq 0x1aca(%rip), %rdi      # 0x497f
leaq 0x12ed(%rip), %rsi      # 0x41a9
movl $0x23d, %edx            # imm = 0x23D
leaq 0x1a92(%rip), %rcx      # 0x495a
callq 0x10c0
cmpl $0x0, -0x14(%rbp)
jne 0x2ed8
jmp 0x2f77
movslq -0x4(%rbp), %rcx
leaq 0x488d(%rip), %rax      # 0x7770
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x2f4e
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x2f1c
movq -0x20(%rbp), %rax
movl $0x3e8, 0xc(%rax)       # imm = 0x3E8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
shll %eax
movslq %eax, %rsi
callq 0x1170
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
shll %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x1130
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/umbrant[P]Non-blocking-Buffers/nbb.c
// Function: nbb_close_channel
int nbb_close_channel(int index)
{
  //TODO: Most probably buggy, needs to be checked some more

  assert(index >= 0 && index < SERVICE_MAX_CHANNELS);

  shmdt((char*)channel_list[index].read);
  if(shmctl(channel_list[index].read_id, IPC_RMID, 0) == -1) {
    return -1;
  }

  shmdt((char*)channel_list[index].write);
  if(shmctl(channel_list[index].write_id, IPC_RMID, 0) == -1) {
    return -1;
  }

  channel_list[index].in_use = 0;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x2f99
cmpl $0xf, -0x8(%rbp)
jge 0x2f99
jmp 0x2fb8
leaq 0x1820(%rip), %rdi      # 0x47c0
leaq 0x1202(%rip), %rsi      # 0x41a9
movl $0x1e4, %edx            # imm = 0x1E4
leaq 0x1838(%rip), %rcx      # 0x47eb
callq 0x10c0
movslq -0x8(%rbp), %rcx
leaq 0x417d(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x1070
movslq -0x8(%rbp), %rcx
leaq 0x4163(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1190
cmpl $-0x1, %eax
jne 0x3000
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3069
movslq -0x8(%rbp), %rcx
leaq 0x4135(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x1070
movslq -0x8(%rbp), %rcx
leaq 0x411a(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movl 0x28(%rax), %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1190
cmpl $-0x1, %eax
jne 0x3049
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3069
movslq -0x8(%rbp), %rcx
leaq 0x40ec(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x50(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/umbrant[P]Non-blocking-Buffers/nbb.c
// Function: nbb_free_channel_slot
int nbb_free_channel_slot()
{
  int i;

  for(i = 0;i < SERVICE_MAX_CHANNELS;i++) {
    if(!channel_list[i].in_use) {
      return i;
    }
  }

  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
cmpl $0xf, -0x8(%rbp)
jge 0x30be
movslq -0x8(%rbp), %rcx
leaq 0x40a4(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x50(%rax)
jne 0x30b1
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x30c5
jmp 0x30b3
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x308b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/mi_ls.c
// Function: main
int main (int argc, char **argv) {
	if (argc != 3) {
		printf("Número de parametros incorrectos\n");
		return -1;
	}
	//Montamos el disco
	if(bmount(argv[1]) < 0){
		printf("No se ha podido abrir el fichero: %s", argv[1]);
		return 0;
	}

	char buffer[64*200];
	memset(buffer,0,tamBloque);
	printf("Directorio %s:\n", argv[2]);

	if(mi_dir (argv[2],(char *)buffer) >= 0) {
		printf("%c[%d;%dmTipo\tPerm.\tmTime\t\t\tNombre%c[%dm\n",27,0,32,27,0);
		puts("-------------------------------------------------------------------");
		printf("%s\n", buffer);
	} else puts("Error: No se ha podido llevar a cabo mi_ls\n");

	bumount();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3210, %rsp           # imm = 0x3210
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x5e89
leaq 0x6e1(%rip), %rdi       # 0x6557
movb $0x0, %al
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5f5e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1280
cmpl $0x0, %eax
jge 0x5ebd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x6d0(%rip), %rdi       # 0x657a
movb $0x0, %al
callq 0x1090
movl $0x0, -0x4(%rbp)
jmp 0x5f5e
leaq -0x3210(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10b0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x6c0(%rip), %rdi       # 0x659f
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x3210(%rbp), %rsi
callq 0x4cf0
cmpl $0x0, %eax
jl 0x5f44
leaq 0x6a9(%rip), %rdi       # 0x65af
movl $0x1b, %r8d
xorl %r9d, %r9d
movl $0x20, %ecx
movl %r8d, %esi
movl %r9d, %edx
movb $0x0, %al
callq 0x1090
leaq 0x6b1(%rip), %rdi       # 0x65d9
callq 0x1060
leaq -0x3210(%rbp), %rsi
leaq 0x6e2(%rip), %rdi       # 0x661d
movb $0x0, %al
callq 0x1090
jmp 0x5f50
leaq 0x6d6(%rip), %rdi       # 0x6621
callq 0x1060
movb $0x0, %al
callq 0x12e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x3210, %rsp           # imm = 0x3210
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_unlocked()
void threadfunc_unlocked()
    {
      start_wait();
      // Wait until main() sends data
      long i;
      for (i = 1; i < count; i++) {
        flat_uint++;
      }
    }

// Assembly:
pushq %rax
callq 0x2430
movq $0x1, (%rsp)
movq (%rsp), %rax
cmpq 0x6ccf(%rip), %rax      # 0x91b8
jge 0x250b
movq 0x6c3e(%rip), %rax      # 0x9130
addq $0x1, %rax
movq %rax, 0x6c33(%rip)      # 0x9130
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x24de
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_unlocked_read()
void threadfunc_unlocked_read()
    {
      start_wait();
      // Wait until main() sends data
      long i,j;
      uint64_t current;
      j = 0;
      for (i = 1; i <= count; i++) {
        current = flat_uint;
        if (current > 0) {
          j++;
        }
        else {
          std::cout << "Error";
        }
      }
      if (j != count) {
        std::cout << "Not matched count j=" << j << "count=" << count <<"\n";
      }
    }

// Assembly:
subq $0x18, %rsp
callq 0x2430
movq $0x0, 0x8(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x6c81(%rip), %rax      # 0x91b8
jg 0x2580
movq 0x6bf0(%rip), %rax      # 0x9130
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jbe 0x255b
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x256e
movq 0x6a66(%rip), %rdi      # 0x8fc8
leaq 0x3acf(%rip), %rsi      # 0x6038
callq 0x2140
jmp 0x2570
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x252b
movq 0x8(%rsp), %rax
cmpq 0x6c2c(%rip), %rax      # 0x91b8
je 0x25db
movq 0x6a33(%rip), %rdi      # 0x8fc8
leaq 0x3aa2(%rip), %rsi      # 0x603e
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x2230
movq %rax, %rdi
leaq 0x3a9b(%rip), %rsi      # 0x6053
callq 0x2140
movq %rax, %rdi
movq 0x6bf1(%rip), %rsi      # 0x91b8
callq 0x2230
movq %rax, %rdi
leaq 0x3b6f(%rip), %rsi      # 0x6145
callq 0x2140
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_mutex()
void threadfunc_mutex()
    {
      start_wait();
      long i;
      for (i = 1; i <= count; i++) {
        theMutex.lock();
        flat_uint++; 
        theMutex.unlock();
      }
    }

// Assembly:
pushq %rax
callq 0x2430
movq $0x1, (%rsp)
movq (%rsp), %rax
cmpq 0x6bbf(%rip), %rax      # 0x91b8
jg 0x2633
leaq 0x6b4e(%rip), %rdi      # 0x9150
callq 0x3da0
movq 0x6b22(%rip), %rax      # 0x9130
addq $0x1, %rax
movq %rax, 0x6b17(%rip)      # 0x9130
leaq 0x6b30(%rip), %rdi      # 0x9150
callq 0x3dd0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x25ee
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_mutex_read()
void threadfunc_mutex_read()
    {
      start_wait();
      uint64_t current;
      long i, j;
      j = 0;
      for (i = 1; i <= count; i++) {
        theMutex.lock();
        current = flat_uint; 
        theMutex.unlock();
        if (current > 0) {
          j++;
        }
        else {
          std::cout << "Error";
        }
      }
      if (j != count) {
        std::cout << "Not matched count j=" << j << "count=" << count <<"\n";
      }
    }

// Assembly:
subq $0x18, %rsp
callq 0x2430
movq $0x0, (%rsp)
movq $0x1, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x6b52(%rip), %rax      # 0x91b8
jg 0x26c7
leaq 0x6ae1(%rip), %rdi      # 0x9150
callq 0x3da0
movq 0x6ab5(%rip), %rax      # 0x9130
movq %rax, 0x10(%rsp)
leaq 0x6ac9(%rip), %rdi      # 0x9150
callq 0x3dd0
cmpq $0x0, 0x10(%rsp)
jbe 0x26a2
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x26b5
movq 0x691f(%rip), %rdi      # 0x8fc8
leaq 0x3988(%rip), %rsi      # 0x6038
callq 0x2140
jmp 0x26b7
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x265a
movq (%rsp), %rax
cmpq 0x6ae6(%rip), %rax      # 0x91b8
je 0x2720
movq 0x68ed(%rip), %rdi      # 0x8fc8
leaq 0x395c(%rip), %rsi      # 0x603e
callq 0x2140
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x2230
movq %rax, %rdi
leaq 0x3956(%rip), %rsi      # 0x6053
callq 0x2140
movq %rax, %rdi
movq 0x6aac(%rip), %rsi      # 0x91b8
callq 0x2230
movq %rax, %rdi
leaq 0x3a2a(%rip), %rsi      # 0x6145
callq 0x2140
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_rwlock()
void threadfunc_rwlock()
    {
      start_wait();
      long i;
      for (i= 0; i <= count; i++) {
    #ifdef WIN32
        AcquireSRWLockExclusive(&srwlock);
        flat_uint++; 
        ReleaseSRWLockExclusive(&srwlock);
    #else
        pthread_rwlock_wrlock(&rwlock);
        flat_uint++; 
        pthread_rwlock_unlock(&rwlock);
    #endif
      }
    }

// Assembly:
pushq %rax
callq 0x2430
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x6a6f(%rip), %rax      # 0x91b8
jg 0x2783
leaq 0x6a26(%rip), %rdi      # 0x9178
callq 0x21b0
movq 0x69d2(%rip), %rax      # 0x9130
addq $0x1, %rax
movq %rax, 0x69c7(%rip)      # 0x9130
leaq 0x6a08(%rip), %rdi      # 0x9178
callq 0x2180
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x273e
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_rwlock_read_wr()
void threadfunc_rwlock_read_wr()
    {
      start_wait();
      long i, j;
      uint64_t current;
      j = 0;
      for (i = 1; i <= count; i++) {
    #ifdef WIN32
        AcquireSRWLockExclusive(&srwlock);
        current = flat_uint; 
        ReleaseSRWLockExclusive(&srwlock);
    #else
        pthread_rwlock_wrlock(&rwlock);
        current = flat_uint; 
        pthread_rwlock_unlock(&rwlock);
    #endif
        if (current > 0) {
          j++;
        }
        else {
          std::cout << "Error";
        }
      }
      if (j != count) {
        std::cout << "Not matched count j=" << j << "count=" << count <<"\n";
      }
    }

// Assembly:
subq $0x18, %rsp
callq 0x2430
movq $0x0, 0x8(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x6a01(%rip), %rax      # 0x91b8
jg 0x2818
leaq 0x69b8(%rip), %rdi      # 0x9178
callq 0x21b0
movq 0x6964(%rip), %rax      # 0x9130
movq %rax, (%rsp)
leaq 0x69a1(%rip), %rdi      # 0x9178
callq 0x2180
cmpq $0x0, (%rsp)
jbe 0x27f3
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2806
movq 0x67ce(%rip), %rdi      # 0x8fc8
leaq 0x3837(%rip), %rsi      # 0x6038
callq 0x2140
jmp 0x2808
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x27ab
movq 0x8(%rsp), %rax
cmpq 0x6994(%rip), %rax      # 0x91b8
je 0x2873
movq 0x679b(%rip), %rdi      # 0x8fc8
leaq 0x380a(%rip), %rsi      # 0x603e
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x2230
movq %rax, %rdi
leaq 0x3803(%rip), %rsi      # 0x6053
callq 0x2140
movq %rax, %rdi
movq 0x6959(%rip), %rsi      # 0x91b8
callq 0x2230
movq %rax, %rdi
leaq 0x38d7(%rip), %rsi      # 0x6145
callq 0x2140
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_rwlock_read_rd()
void threadfunc_rwlock_read_rd()
    {
      start_wait();
      long i, j;
      uint64_t current;
      j = 0;
      for (i = 1; i <= count; i++) {
    #ifdef WIN32
        AcquireSRWLockShared(&srwlock);
        current = flat_uint; 
        ReleaseSRWLockShared(&srwlock);
    #else
        pthread_rwlock_rdlock(&rwlock);
        current = flat_uint; 
        pthread_rwlock_unlock(&rwlock);
    #endif
        if (current > 0) {
          j++;
        }
        else {
          std::cout << "Error";
        }
      }
      if (j != count) {
        std::cout << "Not matched count j=" << j << "count=" << count <<"\n";
      }
    }

// Assembly:
subq $0x18, %rsp
callq 0x2430
movq $0x0, 0x8(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x6911(%rip), %rax      # 0x91b8
jg 0x2908
leaq 0x68c8(%rip), %rdi      # 0x9178
callq 0x2120
movq 0x6874(%rip), %rax      # 0x9130
movq %rax, (%rsp)
leaq 0x68b1(%rip), %rdi      # 0x9178
callq 0x2180
cmpq $0x0, (%rsp)
jbe 0x28e3
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x28f6
movq 0x66de(%rip), %rdi      # 0x8fc8
leaq 0x3747(%rip), %rsi      # 0x6038
callq 0x2140
jmp 0x28f8
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x289b
movq 0x8(%rsp), %rax
cmpq 0x68a4(%rip), %rax      # 0x91b8
je 0x2963
movq 0x66ab(%rip), %rdi      # 0x8fc8
leaq 0x371a(%rip), %rsi      # 0x603e
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x2230
movq %rax, %rdi
leaq 0x3713(%rip), %rsi      # 0x6053
callq 0x2140
movq %rax, %rdi
movq 0x6869(%rip), %rsi      # 0x91b8
callq 0x2230
movq %rax, %rdi
leaq 0x37e7(%rip), %rsi      # 0x6145
callq 0x2140
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_atomic()
void threadfunc_atomic()
    {
      start_wait();
      // Wait until main() sends data
      long i;
      for (i = 1; i <= count; i++) {
        atomic_uint++;
      }
    }

// Assembly:
pushq %rax
callq 0x2430
movq $0x1, (%rsp)
movq (%rsp), %rax
cmpq 0x682f(%rip), %rax      # 0x91b8
jg 0x29a7
leaq 0x681e(%rip), %rdi      # 0x91b0
xorl %esi, %esi
callq 0x3de0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x297e
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_atomic_read()
void threadfunc_atomic_read()
    {
      start_wait();
      // Wait until main() sends data
      long i,j;
      uint64_t current;
      j = 0;
      for (i = 1; i <= count; i++) {
        current = atomic_uint;
        if (current > 0) {
          j++;
        }
        else {
          std::cout << "Error";
        }
      }
      if (j != count) {
        std::cout << "Not matched count j=" << j << "count=" << count <<"\n";
      }
    }

// Assembly:
subq $0x18, %rsp
callq 0x2430
movq $0x0, 0x8(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x67e1(%rip), %rax      # 0x91b8
jg 0x2a25
leaq 0x67d0(%rip), %rdi      # 0x91b0
callq 0x3ec0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jbe 0x2a00
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2a13
movq 0x65c1(%rip), %rdi      # 0x8fc8
leaq 0x362a(%rip), %rsi      # 0x6038
callq 0x2140
jmp 0x2a15
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x29cb
movq 0x8(%rsp), %rax
cmpq 0x6787(%rip), %rax      # 0x91b8
je 0x2a80
movq 0x658e(%rip), %rdi      # 0x8fc8
leaq 0x35fd(%rip), %rsi      # 0x603e
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x2230
movq %rax, %rdi
leaq 0x35f6(%rip), %rsi      # 0x6053
callq 0x2140
movq %rax, %rdi
movq 0x674c(%rip), %rsi      # 0x91b8
callq 0x2230
movq %rax, %rdi
leaq 0x36ca(%rip), %rsi      # 0x6145
callq 0x2140
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_atomic_set_release()
void threadfunc_atomic_set_release()
    {
      start_wait();
      // Wait until main() sends data
      long i;
      for (i = 1; i <= count; i++) {
        atomic_uint.store(i, std::memory_order_release);
      }
    }

// Assembly:
subq $0x48, %rsp
callq 0x2430
movq $0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x670a(%rip), %rax      # 0x91b8
jg 0x2b66
movq 0x20(%rsp), %rax
leaq 0x66f0(%rip), %rcx      # 0x91b0
movq %rcx, 0x40(%rsp)
movq %rax, 0x38(%rsp)
movl $0x3, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x34(%rsp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x44e0
movl %eax, 0x1c(%rsp)
jmp 0x2af0
movl 0x1c(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rsp)
subl $0x3, %eax
je 0x2b2b
jmp 0x2b11
movl 0xc(%rsp), %eax
subl $0x5, %eax
je 0x2b3a
jmp 0x2b1c
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x2b51
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x2b51
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
xchgq %rax, (%rcx)
jmp 0x2b51
movq %rax, %rdi
callq 0x4290
jmp 0x2b53
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2aa2
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_atomic_set_cst()
void threadfunc_atomic_set_cst()
    {
      start_wait();
      // Wait until main() sends data
      long i;
      for (i = 1; i <= count; i++) {
        atomic_uint.store(i, std::memory_order_seq_cst);
      }
    }

// Assembly:
subq $0x48, %rsp
callq 0x2430
movq $0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x662a(%rip), %rax      # 0x91b8
jg 0x2c46
movq 0x20(%rsp), %rax
leaq 0x6610(%rip), %rcx      # 0x91b0
movq %rcx, 0x40(%rsp)
movq %rax, 0x38(%rsp)
movl $0x5, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x34(%rsp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x44e0
movl %eax, 0x1c(%rsp)
jmp 0x2bd0
movl 0x1c(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rsp)
subl $0x3, %eax
je 0x2c0b
jmp 0x2bf1
movl 0xc(%rsp), %eax
subl $0x5, %eax
je 0x2c1a
jmp 0x2bfc
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x2c31
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x2c31
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
xchgq %rax, (%rcx)
jmp 0x2c31
movq %rax, %rdi
callq 0x4290
jmp 0x2c33
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2b82
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_atomic_set_relaxed()
void threadfunc_atomic_set_relaxed()
    {
      start_wait();
      // Wait until main() sends data
      long i;
      for (i = 1; i <= count; i++) {
        atomic_uint.store(i, std::memory_order_relaxed);
      }
    }

// Assembly:
subq $0x48, %rsp
callq 0x2430
movq $0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x654a(%rip), %rax      # 0x91b8
jg 0x2d26
movq 0x20(%rsp), %rax
leaq 0x6530(%rip), %rcx      # 0x91b0
movq %rcx, 0x40(%rsp)
movq %rax, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x34(%rsp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x44e0
movl %eax, 0x1c(%rsp)
jmp 0x2cb0
movl 0x1c(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rsp)
subl $0x3, %eax
je 0x2ceb
jmp 0x2cd1
movl 0xc(%rsp), %eax
subl $0x5, %eax
je 0x2cfa
jmp 0x2cdc
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x2d11
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x2d11
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
xchgq %rax, (%rcx)
jmp 0x2d11
movq %rax, %rdi
callq 0x4290
jmp 0x2d13
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2c62
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_atomic_read_acquire()
void threadfunc_atomic_read_acquire()
    {
      start_wait();
      // Wait until main() sends data
      long i,j;
      uint64_t current;
      j = 0;
      for (i = 1; i <= count; i++) {
        current = atomic_uint.load(std::memory_order_acquire);
        if (current > 0) {
          j++;
        }
        else {
          std::cout << "Error!";
        }
      }
      if (j != count) {
        std::cout << "Not matched count j=" << j << "count=" << count <<"\n";
      }
    }

// Assembly:
subq $0x48, %rsp
callq 0x2430
movq $0x0, 0x20(%rsp)
movq $0x1, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x62d1(%rip), %rax      # 0x91b8
jg 0x2fae
leaq 0x62bc(%rip), %rax      # 0x91b0
movq %rax, 0x40(%rsp)
movl $0x2, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x44e0
movl %eax, 0x38(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x14(%rsp)
decl %eax
subl $0x2, %eax
jb 0x2f48
jmp 0x2f2e
movl 0x14(%rsp), %eax
subl $0x5, %eax
je 0x2f57
jmp 0x2f39
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x2f64
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x2f64
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jbe 0x2f86
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2f99
movq 0x603b(%rip), %rdi      # 0x8fc8
leaq 0x30ce(%rip), %rsi      # 0x6062
callq 0x2140
jmp 0x2f9b
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2edb
movq 0x20(%rsp), %rax
cmpq 0x61fe(%rip), %rax      # 0x91b8
je 0x3009
movq 0x6005(%rip), %rdi      # 0x8fc8
leaq 0x3074(%rip), %rsi      # 0x603e
callq 0x2140
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x2230
movq %rax, %rdi
leaq 0x306d(%rip), %rsi      # 0x6053
callq 0x2140
movq %rax, %rdi
movq 0x61c3(%rip), %rsi      # 0x91b8
callq 0x2230
movq %rax, %rdi
leaq 0x3141(%rip), %rsi      # 0x6145
callq 0x2140
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/msender6.c
// Function: usage
void usage()
{
    printf("Usage: ./msender -s source -g group -p port -h hops -l length -c count\n");
	printf(" -s souruce	the source ip\n");
	printf(" -i ifname 	the outgoing interface name\n");
	printf(" -g group	the group ip\n");
	printf(" -p port	the port\n");
	printf(" -h hops	the hops, default hops is 1\n");
	printf(" -l length	the packet length, default length is 256 bytes\n");
	printf(" -c count	the packet count, default count is unlimited\n");
    printf(" Version	%s\n",version);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe2d(%rip), %rdi       # 0x2048
movb $0x0, %al
callq 0x1060
leaq 0xe67(%rip), %rdi       # 0x2090
movb $0x0, %al
callq 0x1060
leaq 0xe74(%rip), %rdi       # 0x20ab
movb $0x0, %al
callq 0x1060
leaq 0xe8f(%rip), %rdi       # 0x20d4
movb $0x0, %al
callq 0x1060
leaq 0xe99(%rip), %rdi       # 0x20ec
movb $0x0, %al
callq 0x1060
leaq 0xe9e(%rip), %rdi       # 0x20ff
movb $0x0, %al
callq 0x1060
leaq 0xeb6(%rip), %rdi       # 0x2125
movb $0x0, %al
callq 0x1060
leaq 0xee3(%rip), %rdi       # 0x2160
movb $0x0, %al
callq 0x1060
leaq 0xf0d(%rip), %rdi       # 0x2198
leaq 0xf13(%rip), %rsi       # 0x21a5
movb $0x0, %al
callq 0x1060
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/array.c
// Function: rarr_init
void rarr_init(
	ResizableArray *rarr,
	size_t item_size
) {
	assert(rarr);
	assert(item_size > 0);

	rarr->size = 0;
	rarr->len = 0;
	rarr->item_size = item_size;
	rarr->buffer = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa2c9
jmp 0xa2e8
leaq 0x3bd34(%rip), %rdi     # 0x46004
leaq 0x3bd32(%rip), %rsi     # 0x46009
movl $0xf, %edx
leaq 0x3bd2e(%rip), %rcx     # 0x46011
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
jbe 0xa2f1
jmp 0xa310
leaq 0x3bd42(%rip), %rdi     # 0x4603a
leaq 0x3bd0a(%rip), %rsi     # 0x46009
movl $0x10, %edx
leaq 0x3bd06(%rip), %rcx     # 0x46011
callq 0xa0b0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/array.c
// Function: rarr_free
void rarr_free(ResizableArray *rarr) {
	assert(rarr);

	if (rarr->buffer != NULL) {
		free(rarr->buffer);	
	}

	rarr->size = 0;
	rarr->len = 0;
	rarr->item_size = 0;
	rarr->buffer = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa365
jmp 0xa384
leaq 0x3bc98(%rip), %rdi     # 0x46004
leaq 0x3bc96(%rip), %rsi     # 0x46009
movl $0x19, %edx
leaq 0x3bcc9(%rip), %rcx     # 0x46048
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xa39c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xa1b0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/array.c
// Function: rarr_append_with_raw
void rarr_append_with_raw(
	ResizableArray *dst,
	void *src,
	size_t len
) {
	assert(dst);
	assert(src);
	
	if (len == 0) {
		return;
	}

	if (dst->len + len > dst->size) {
		_inc_buffer_size(dst, len);
	}

	memcpy((uint8_t *)(dst->buffer) + _BYTE_COUNT(dst, dst->len), src, _BYTE_COUNT(dst, len));
	dst->len += len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa3fd
jmp 0xa41c
leaq 0x3bc65(%rip), %rdi     # 0x46069
leaq 0x3bbfe(%rip), %rsi     # 0x46009
movl $0x39, %edx
leaq 0x3bc56(%rip), %rcx     # 0x4606d
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xa425
jmp 0xa444
leaq 0x3db90(%rip), %rdi     # 0x47fbc
leaq 0x3bbd6(%rip), %rsi     # 0x46009
movl $0x3a, %edx
leaq 0x3bc2e(%rip), %rcx     # 0x4606d
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
jne 0xa44d
jmp 0xa4b1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0xa46f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa4c0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
imulq 0x10(%rcx), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
imulq 0x10(%rax), %rdx
callq 0xa120
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/array.c
// Function: inc_buffer_size
static void _inc_buffer_size(
	ResizableArray *rarr,
	size_t inc_size
) {
	assert(rarr);
	assert(inc_size > 0);

	rarr->size = rarr->size + 2 * inc_size;
	if (rarr->buffer == NULL) {
		rarr->buffer = (char *)malloc(_BYTE_COUNT(rarr, rarr->size));
	} else {
		rarr->buffer = (char *)realloc(rarr->buffer, _BYTE_COUNT(rarr, rarr->size));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa4d9
jmp 0xa4f8
leaq 0x3bb24(%rip), %rdi     # 0x46004
leaq 0x3bb22(%rip), %rsi     # 0x46009
movl $0x29, %edx
leaq 0x3bed4(%rip), %rcx     # 0x463c7
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
jbe 0xa501
jmp 0xa520
leaq 0x3beef(%rip), %rdi     # 0x463f7
leaq 0x3bafa(%rip), %rsi     # 0x46009
movl $0x2a, %edx
leaq 0x3beac(%rip), %rcx     # 0x463c7
callq 0xa0b0
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
shlq %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xa565
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
imulq 0x10(%rax), %rdi
callq 0xa130
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xa58d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
imulq 0x10(%rax), %rsi
callq 0xa140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/array.c
// Function: rarr_append_with_rarr
void rarr_append_with_rarr(
	ResizableArray *dst,
	ResizableArray *src
) {
	assert(dst);
	assert(src);
	assert(dst->item_size == src->item_size);

	rarr_append_with_raw(dst, src->buffer, src->len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa5b9
jmp 0xa5d8
leaq 0x3baa9(%rip), %rdi     # 0x46069
leaq 0x3ba42(%rip), %rsi     # 0x46009
movl $0x4c, %edx
leaq 0x3bad6(%rip), %rcx     # 0x460a9
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xa5e1
jmp 0xa600
leaq 0x3d9d4(%rip), %rdi     # 0x47fbc
leaq 0x3ba1a(%rip), %rsi     # 0x46009
movl $0x4d, %edx
leaq 0x3baae(%rip), %rcx     # 0x460a9
callq 0xa0b0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xa614
jmp 0xa633
leaq 0x3bacd(%rip), %rdi     # 0x460e8
leaq 0x3b9e7(%rip), %rsi     # 0x46009
movl $0x4e, %edx
leaq 0x3ba7b(%rip), %rcx     # 0x460a9
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0xa3e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/array.c
// Function: rarr_insert_with_raw
void rarr_insert_with_raw(
	ResizableArray *dst,
	void *src,
	size_t len,
	size_t pos
) {
	assert(dst);
	assert(src);

	if (len == 0) {
		return;
	}

	if (dst->len + len > dst->size) {
		_inc_buffer_size(dst, len);
	}

	memcpy(dst->buffer + _BYTE_COUNT(dst, pos + len), dst->buffer + _BYTE_COUNT(dst, pos), _BYTE_COUNT(dst, dst->len - pos));
	memcpy(dst->buffer + _BYTE_COUNT(dst, pos), src, _BYTE_COUNT(dst, len));
	dst->len += len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa681
jmp 0xa6a0
leaq 0x3b9e1(%rip), %rdi     # 0x46069
leaq 0x3b97a(%rip), %rsi     # 0x46009
movl $0x59, %edx
leaq 0x3ba6e(%rip), %rcx     # 0x46109
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xa6a9
jmp 0xa6c8
leaq 0x3d90c(%rip), %rdi     # 0x47fbc
leaq 0x3b952(%rip), %rsi     # 0x46009
movl $0x5a, %edx
leaq 0x3ba46(%rip), %rcx     # 0x46109
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
jne 0xa6d4
jmp 0xa782
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0xa6f6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa4c0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq 0x10(%rcx), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq 0x10(%rcx), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
subq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
imulq 0x10(%rax), %rdx
callq 0xa120
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq 0x10(%rcx), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
imulq 0x10(%rax), %rdx
callq 0xa120
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/lexer.c
// Function: default_invalid_token
static void _default_invalid_token(LexerContext *ctx) {
	assert(ctx);
	assert(ctx->file);

	fprintf(
		stderr,
		"Lexer Error(%s:%d,%d): invalid token, near:\n",
		ctx->file, ctx->line, ctx->column
	);

	fputc('\n', stderr);
	fputc('\t', stderr);

	bool flag = true;
	for (int i = 0; i < 60 && ctx->index + i < ctx->len; i++) {
		char chr = ctx->source[ctx->index + i];
		if (isspace(chr)) {
			if (flag) {
				fputc(' ', stderr);
				flag = false;
			}
		} else {
			fputc(chr, stderr);
			flag = true;
		}
	}

	fputc('\n', stderr);
	fputc('\n', stderr);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb365
jmp 0xb384
leaq 0x427f5(%rip), %rdi     # 0x4db61
leaq 0x41020(%rip), %rsi     # 0x4c393
movl $0x39, %edx
leaq 0x3b6be(%rip), %rcx     # 0x46a3d
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb390
jmp 0xb3af
leaq 0x3b6d2(%rip), %rdi     # 0x46a69
leaq 0x40ff5(%rip), %rsi     # 0x4c393
movl $0x3a, %edx
leaq 0x3b693(%rip), %rcx     # 0x46a3d
callq 0xa0b0
movq 0x4cc42(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %r8d
leaq 0x3b69d(%rip), %rsi     # 0x46a73
movb $0x0, %al
callq 0xa100
movq 0x4cc14(%rip), %rax     # 0x57ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0xa0e0
movq 0x4cc00(%rip), %rax     # 0x57ff8
movq (%rax), %rsi
movl $0x9, %edi
callq 0xa0e0
movb $0x1, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x3c, -0x10(%rbp)
movb %al, -0x12(%rbp)
jge 0xb432
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
addl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
setl %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0xb43b
jmp 0xb4ba
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x34(%rcx), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
callq 0xa1a0
movq (%rax), %rax
movsbl -0x11(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xb493
testb $0x1, -0x9(%rbp)
je 0xb491
movq 0x4cb78(%rip), %rax     # 0x57ff8
movq (%rax), %rsi
movl $0x20, %edi
callq 0xa0e0
movb $0x0, -0x9(%rbp)
jmp 0xb4aa
movsbl -0x11(%rbp), %edi
movq 0x4cb5a(%rip), %rax     # 0x57ff8
movq (%rax), %rsi
callq 0xa0e0
movb $0x1, -0x9(%rbp)
jmp 0xb4ac
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb410
movq 0x4cb37(%rip), %rax     # 0x57ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0xa0e0
movq 0x4cb23(%rip), %rax     # 0x57ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0xa0e0
movl $0x1, %edi
callq 0xa180
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/lexer.c
// Function: default_alloc_mem_error
static void _default_alloc_mem_error(LexerContext *ctx) {
	assert(ctx);
	assert(ctx->file);

	fprintf(stderr, "Lexer Error(%s:%d,%d): cannot allocate memory!\n", ctx->file, ctx->line, ctx->column);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb505
jmp 0xb524
leaq 0x42655(%rip), %rdi     # 0x4db61
leaq 0x40e80(%rip), %rsi     # 0x4c393
movl $0x59, %edx
leaq 0x3b581(%rip), %rcx     # 0x46aa0
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb530
jmp 0xb54f
leaq 0x3b532(%rip), %rdi     # 0x46a69
leaq 0x40e55(%rip), %rsi     # 0x4c393
movl $0x5a, %edx
leaq 0x3b556(%rip), %rcx     # 0x46aa0
callq 0xa0b0
movq 0x4caa2(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %r8d
leaq 0x3b558(%rip), %rsi     # 0x46ace
movb $0x0, %al
callq 0xa100
movl $0x1, %edi
callq 0xa180
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/lexer.c
// Function: lexer_free_context
void lexer_free_context(LexerContext * ctx) {
	assert(ctx);

	for (int i = 0; i < RARR_LEN(&(ctx->rarr_file)); i++) {
		free(RARR_ELEMENT(&(ctx->rarr_file), i, char *));
	}
	rarr_free(&(ctx->rarr_file));

	LexerToken *token = ctx->tokens;
	while (token != NULL) {
		LexerToken *temp = token;
		token = token->tks_next;
		lexer_free_token(ctx, temp);
	}

	free(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb5a5
jmp 0xb5c4
leaq 0x425b5(%rip), %rdi     # 0x4db61
leaq 0x40de0(%rip), %rsi     # 0x4c393
movl $0x91, %edx
leaq 0x3afec(%rip), %rcx     # 0x465ab
callq 0xa0b0
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xb602
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rdx
imulq 0x18(%rdx), %rcx
movq (%rax,%rcx), %rdi
callq 0xa1b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb5cb
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0xa350
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb645
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb660
jmp 0xb61b
movq -0x8(%rbp), %rdi
callq 0xa1b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/lexer.c
// Function: lexer_next_char
int lexer_next_char(LexerContext *ctx) {
	assert(ctx);

	if (ctx->index + 1 < ctx->len) {
		ctx->index++;
		char chr = ctx->source[ctx->index];
		if (chr == '\n') {
			ctx->line++;
			ctx->column = 0;
		} else {
			ctx->column++;
		}
		return chr;
	} else {
		ctx->index = ctx->len;
		return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb6e5
jmp 0xb704
leaq 0x42475(%rip), %rdi     # 0x4db61
leaq 0x40ca0(%rip), %rsi     # 0x4c393
movl $0xa6, %edx
leaq 0x3aed4(%rip), %rcx     # 0x465d3
callq 0xa0b0
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0xb773
movq -0x10(%rbp), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x34(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0xb75d
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x3c(%rax)
jmp 0xb76a
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movsbl -0x11(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb788
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/lexer.c
// Function: lexer_match_string
bool lexer_match_string(
	LexerContext *ctx,
	const char *str
) {
	assert(ctx);
	assert(str);

	size_t len = strlen(str);
	for (int i = 0; i < len; i++) {
		if (lexer_peek_char(ctx, 1 + i) != str[i]) {
			return false;
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb7b9
jmp 0xb7d8
leaq 0x423a1(%rip), %rdi     # 0x4db61
leaq 0x40bcc(%rip), %rsi     # 0x4c393
movl $0xbc, %edx
leaq 0x3ae24(%rip), %rcx     # 0x465f7
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xb7e1
jmp 0xb800
leaq 0x3c3a2(%rip), %rdi     # 0x47b8a
leaq 0x40ba4(%rip), %rsi     # 0x4c393
movl $0xbd, %edx
leaq 0x3adfc(%rip), %rcx     # 0x465f7
callq 0xa0b0
movq -0x18(%rbp), %rdi
callq 0xa080
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xb850
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
addl $0x1, %esi
callq 0xb860
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xb843
movb $0x0, -0x1(%rbp)
jmp 0xb854
jmp 0xb845
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb814
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/lexer.c
// Function: lexer_peek_char
int lexer_peek_char(LexerContext *ctx, int n) {
	assert(ctx);

	int index = ctx->index + n;
	if (index < 0 || index >= ctx->len) {
		return -1;
	} else {
		return ctx->source[index];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb878
jmp 0xb897
leaq 0x422e2(%rip), %rdi     # 0x4db61
leaq 0x40b0d(%rip), %rsi     # 0x4c393
movl $0xca, %edx
leaq 0x3ad9c(%rip), %rcx     # 0x4662e
callq 0xa0b0
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0xb8b6
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jl 0xb8bf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb8d2
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/lexer.c
// Function: lexer_reset_token
void lexer_reset_token(LexerContext *ctx, int head) {
	assert(ctx);

	if (head) {
		ctx->current = ctx->head;
	} else {
		ctx->current = ctx->tail;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb8f8
jmp 0xb917
leaq 0x42262(%rip), %rdi     # 0x4db61
leaq 0x40a8d(%rip), %rsi     # 0x4c393
movl $0xd8, %edx
leaq 0x3ad45(%rip), %rcx     # 0x46657
callq 0xa0b0
cmpl $0x0, -0xc(%rbp)
je 0xb92f
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
jmp 0xb93f
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/lexer.c
// Function: lexer_next_token
LexerToken * lexer_next_token(LexerContext *ctx) {
	assert(ctx);

	LexerToken *token = ctx->current;

	if (token != NULL) {
		ctx->current = token->next;
	}

	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb965
jmp 0xb984
leaq 0x421f5(%rip), %rdi     # 0x4db61
leaq 0x40a20(%rip), %rsi     # 0x4c393
movl $0xe2, %edx
leaq 0x3ad04(%rip), %rcx     # 0x46683
callq 0xa0b0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb9a7
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/lexer.c
// Function: lexer_prev_token
LexerToken * lexer_prev_token(LexerContext *ctx) {
	assert(ctx);

	LexerToken *token = ctx->current;

	if (token != NULL) {
		ctx->current = token->prev;
	}

	return ctx->current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb9d5
jmp 0xb9f4
leaq 0x42185(%rip), %rdi     # 0x4db61
leaq 0x409b0(%rip), %rsi     # 0x4c393
movl $0xee, %edx
leaq 0x3acc1(%rip), %rcx     # 0x466b0
callq 0xa0b0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xba17
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)