LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/umbrant[P]Non-blocking-Buffers/nbb.c
// Function: init_nameserver
int init_nameserver()
{
  FILE* pFile;

  // XXX: Initial semaphore value? Use 1 for now...
  sem_id = sem_open(SEM_KEY, O_CREAT, 0666, 1);
  if(sem_id == SEM_FAILED) {
    perror("! Unable to obtain semaphore\n");
    return -1;
  }

  if(nbb_open_channel(NULL, NAMESERVER_READ, NAMESERVER_WRITE, IPC_CREAT)) {
    printf("! Unable to open channel\n");
    return -1;
  }

  pFile = fopen(NAMESERVER_PID_FILE,"w+");
  fprintf(pFile,"%d",(int)getpid());
  fclose(pFile);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x15f5(%rip), %rdi      # 0x31d7
movl $0x40, %esi
movl $0x1b6, %edx            # imm = 0x1B6
movl $0x1, %ecx
xorl %eax, %eax
callq 0x1110
movq %rax, 0x4b61(%rip)      # 0x6760
testq %rax, %rax
je 0x1c73
xorl %ebx, %ebx
xorl %edi, %edi
movl $0xfa1, %esi            # imm = 0xFA1
movl $0xfa0, %edx            # imm = 0xFA0
movl $0x200, %ecx            # imm = 0x200
callq 0x173a
testl %eax, %eax
je 0x1c33
leaq 0x1d31(%rip), %rdi      # 0x3958
callq 0x1070
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x1c69
leaq 0x1e56(%rip), %rdi      # 0x3a90
leaq 0x15ba(%rip), %rsi      # 0x31fb
callq 0x11a0
movq %rax, %r14
callq 0x1090
leaq 0x13c8(%rip), %rsi      # 0x301d
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1120
movq %r14, %rdi
callq 0x10a0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1563(%rip), %rdi      # 0x31dd
callq 0x11b0
jmp 0x1c2c
// File: /workspace/github_c_makefile_star2_O3/umbrant[P]Non-blocking-Buffers/nbb.c
// Function: nbb_send
int nbb_send(const char* destination, const char* msg, size_t msg_len)
{
  int i;
  // int retval;

  printf("** dest: %s, msg: %s, msg_len: %d\n", destination, msg, (int) msg_len);
  assert(destination != NULL && msg != NULL);

  if (msg_len == 0) {
    printf("! nbb_send(): nothing to send (0 length passed in)\n");
    return 0;
  }

  // Since i = 0 is already reserved for nameserver
  for(i = 1; i < SERVICE_MAX_CHANNELS;i++) {
    if(channel_list[i].in_use && connected_nodes[i].name &&
       !strcmp(destination, connected_nodes[i].name)) {
      break;
    }
  }

  if(i == SERVICE_MAX_CHANNELS) {
    printf("! nbb_send(): Process not found\n");
    return -1;
  }

  nbb_insert_item(i, msg, msg_len); 
  kill(connected_nodes[i].pid, SIGUSR1);

  printf("** Send '%.*s' to %s\n", (int) msg_len, msg, destination);

  /* Not needed
  do { 
    retval = nbb_read_item(i, (void**)&recv, &recv_len);
  } while (retval == BUFFER_EMPTY || retval == BUFFER_EMPTY_PRODUCER_INSERTING); 

  if(strcmp(recv, NEW_CONN_NOTIFY_MSG)) {
    nbb_flush_shm(i, recv, recv_len);
  }

  printf("** Received '%.*s' from the service\n", (int) recv_len, recv);
*/

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x11c0(%rip), %rdi      # 0x354a
movq %rbx, %rsi
movq %r14, %rdx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x10c0
testq %rbx, %rbx
je 0x2469
testq %r14, %r14
je 0x2469
testq %r15, %r15
je 0x2410
movq %r15, (%rsp)
movl $0x18, %r12d
movl $0x1, %ebp
leaq 0x3e21(%rip), %r15      # 0x61e8
leaq 0x42a2(%rip), %r13      # 0x6670
cmpl $0x0, (%r15)
je 0x23ea
movq -0x8(%r12,%r13), %rsi
testq %rsi, %rsi
je 0x23ea
movq %rbx, %rdi
callq 0x1100
testl %eax, %eax
je 0x2420
addq $0x10, %r12
incl %ebp
addq $0x58, %r15
cmpq $0xf8, %r12
jne 0x23ce
leaq 0x1633(%rip), %rdi      # 0x3a37
callq 0x1070
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x2458
leaq 0x1640(%rip), %rdi      # 0x3a57
callq 0x1070
xorl %ebp, %ebp
jmp 0x2458
movl %ebp, %edi
movq %r14, %rsi
movq (%rsp), %r15
movq %r15, %rdx
callq 0x190b
movl (%r12,%r13), %edi
movl $0xa, %esi
callq 0x1150
leaq 0x117b(%rip), %rdi      # 0x35c1
xorl %ebp, %ebp
movl %r15d, %esi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10c0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10fd(%rip), %rdi      # 0x356d
leaq 0xd1e(%rip), %rsi       # 0x3195
leaq 0x1112(%rip), %rcx      # 0x3590
movl $0x11c, %edx            # imm = 0x11C
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/umbrant[P]Non-blocking-Buffers/nbb.c
// Function: nbb_set_cb_new_connection
void nbb_set_cb_new_connection(const char* owner, cb_new_conn_func func, void* arg)
{
  int i;

  // |arg| can be NULL
  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_conn = func;
      channel_list[i].arg = arg;
      printf("***NBB***: Set new_conn callback for '%s'\n", owner);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x250b
movq %rsi, %r14
testq %rsi, %rsi
je 0x250b
movq %rdx, %rbx
movq %rdi, %r15
movl $0xa8, %r13d
leaq 0x3c8d(%rip), %rbp      # 0x6140
leaq 0x102c(%rip), %r12      # 0x34e6
cmpl $0x0, (%r13,%rbp)
je 0x24ef
movq -0x20(%r13,%rbp), %rsi
testq %rsi, %rsi
je 0x24ef
movq %r15, %rdi
callq 0x1100
testl %eax, %eax
jne 0x24ef
movq %r14, -0x18(%r13,%rbp)
movq %rbx, -0x8(%r13,%rbp)
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10c0
addq $0x58, %r13
cmpq $0x578, %r13            # imm = 0x578
jne 0x24ba
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf6f(%rip), %rdi       # 0x3481
leaq 0xc7c(%rip), %rsi       # 0x3195
leaq 0xf7f(%rip), %rcx       # 0x349f
movl $0xf6, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x258a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x258a
movq %rdi, %r14
movl $0xa8, %r15d
leaq 0x3bf1(%rip), %r12      # 0x6140
cmpl $0x0, (%r15,%r12)
je 0x2571
movq -0x20(%r15,%r12), %rsi
testq %rsi, %rsi
je 0x2571
movq %r14, %rdi
callq 0x1100
testl %eax, %eax
jne 0x2571
movq %rbx, -0x10(%r15,%r12)
addq $0x58, %r15
cmpq $0x578, %r15            # imm = 0x578
jne 0x254f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xef0(%rip), %rdi       # 0x3481
leaq 0xbfd(%rip), %rsi       # 0x3195
leaq 0xf72(%rip), %rcx       # 0x3511
movl $0x109, %edx            # imm = 0x109
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0xf, %edi
jae 0x2641
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2660
movl %edx, %r14d
testl %edx, %edx
js 0x2660
je 0x2636
movl %edi, %eax
leaq (%rax,%rax,2), %rax
leaq 0x4191(%rip), %rcx      # 0x6770
leaq (%rcx,%rax,8), %r15
movl 0x8(%r15), %ecx
movl 0xc(%r15), %eax
leal (%rcx,%r14), %ebp
cmpl %eax, %ebp
jle 0x261e
testl %eax, %eax
jne 0x2604
movl $0x3e8, 0xc(%r15)       # imm = 0x3E8
movl $0x3e8, %eax            # imm = 0x3E8
movq (%r15), %rdi
addl %eax, %eax
movslq %eax, %rsi
callq 0x1170
movq %rax, (%r15)
shll 0xc(%r15)
movl 0x8(%r15), %ecx
jmp 0x2621
movq (%r15), %rax
movslq %ecx, %rdi
addq %rax, %rdi
movl %r14d, %edx
movq %rbx, %rsi
callq 0x1130
movl %ebp, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1128(%rip), %rdi      # 0x3770
leaq 0xb46(%rip), %rsi       # 0x3195
leaq 0x1193(%rip), %rcx      # 0x37e9
movl $0x23c, %edx            # imm = 0x23C
callq 0x10d0
leaq 0x11a7(%rip), %rdi      # 0x380e
leaq 0xb27(%rip), %rsi       # 0x3195
leaq 0x1174(%rip), %rcx      # 0x37e9
movl $0x23d, %edx            # imm = 0x23D
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
cmpl $0xf, %edi
jae 0x26e7
movl %edi, %eax
imulq $0x58, %rax, %r15
leaq 0x3aaa(%rip), %r14      # 0x6140
movq (%r15,%r14), %rdi
callq 0x1080
movl 0x10(%r15,%r14), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1190
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x26df
addq %r15, %r14
movq 0x18(%r14), %rdi
callq 0x1080
movl 0x28(%r14), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1190
cmpl $-0x1, %eax
je 0x26df
movl $0x0, 0x50(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xf61(%rip), %rdi       # 0x364f
leaq 0xaa0(%rip), %rsi       # 0x3195
leaq 0xf7e(%rip), %rcx       # 0x367a
movl $0x1e4, %edx            # imm = 0x1E4
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/umbrant[P]Non-blocking-Buffers/nbb.c
// Function: nbb_read_bytes
int nbb_read_bytes(int slot, char* buf, int size)
{
  assert(slot >= 0 && buf != NULL && size >= 0);

  delay_buffer_t* delay_buffer = &(delay_buffers[slot]);
  printf("***NBB***: Delay buffer %d: %d/%d\n",
         slot, delay_buffer->len, delay_buffer->capacity);
  assert(delay_buffer->capacity >= delay_buffer->len);

  // Attempt to read 0 bytes or buffer has nothing to read
  if (size == 0 || delay_buffer->content == NULL || delay_buffer->len == 0) {
    return 0;
  }

  assert(delay_buffer->content != NULL && delay_buffer->len > 0);

  // Read minimum of the requested length and available data
  if(size > delay_buffer->len) {
    size = delay_buffer->len;
  }

  // Read |size| bytes into |buf| and update statistics
  memcpy(buf, delay_buffer->content, size);
  channel_list[slot].read_count += size;

  // Move remaining data (if any) into the front of buffer
  int new_len = delay_buffer->len - size;
  if (new_len > 0) {
    memmove(delay_buffer->content, delay_buffer->content + size, new_len);
  }
  delay_buffer->len = new_len;

  return size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rsi, %rsi
je 0x27fd
movl %edx, %ebx
movl %edi, %esi
movl %edx, %eax
orl %edi, %eax
js 0x27fd
movl %esi, %r15d
leaq (%r15,%r15,2), %r12
leaq 0x4016(%rip), %r13      # 0x6770
movl 0x8(%r13,%r12,8), %edx
movl 0xc(%r13,%r12,8), %ecx
leaq 0xf75(%rip), %rdi       # 0x36e0
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x10c0
movl 0x8(%r13,%r12,8), %eax
cmpl %eax, 0xc(%r13,%r12,8)
jl 0x281c
testl %ebx, %ebx
je 0x27ec
leaq (,%r12,8), %r12
addq %r13, %r12
movq (%r12), %rsi
testq %rsi, %rsi
sete %cl
testl %eax, %eax
sete %dl
orb %cl, %dl
jne 0x27ec
testl %eax, %eax
jle 0x283b
cmpl %ebx, %eax
cmovll %eax, %ebx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1130
imulq $0x58, %r15, %rax
leaq 0x3977(%rip), %rcx      # 0x6140
addl %ebx, 0x14(%rax,%rcx)
movl 0x8(%r12), %ebp
subl %ebx, %ebp
jle 0x27e5
movq (%r12), %rdi
leaq (%rdi,%rbx), %rsi
movl %ebp, %edx
callq 0x1180
movl %ebp, 0x8(%r12)
movl %ebx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe91(%rip), %rdi       # 0x3695
leaq 0x98a(%rip), %rsi       # 0x3195
leaq 0xea9(%rip), %rcx       # 0x36bb
movl $0x206, %edx            # imm = 0x206
callq 0x10d0
leaq 0xee0(%rip), %rdi       # 0x3703
leaq 0x96b(%rip), %rsi       # 0x3195
leaq 0xe8a(%rip), %rcx       # 0x36bb
movl $0x20b, %edx            # imm = 0x20B
callq 0x10d0
leaq 0xeed(%rip), %rdi       # 0x372f
leaq 0x94c(%rip), %rsi       # 0x3195
leaq 0xe6b(%rip), %rcx       # 0x36bb
movl $0x212, %edx            # imm = 0x212
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x3208, %rsp           # imm = 0x3208
cmpl $0x3, %edi
jne 0x3d83
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x127c
testl %eax, %eax
js 0x3d96
movq %rsp, %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b0
movq 0x10(%rbx), %rsi
leaq 0x815(%rip), %rdi       # 0x454d
xorl %eax, %eax
callq 0x1090
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x31e4
testl %eax, %eax
js 0x3dac
leaq 0x807(%rip), %rdi       # 0x455d
movl $0x1b, %esi
xorl %edx, %edx
movl $0x20, %ecx
movl $0x1b, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x1090
leaq 0x80e(%rip), %rdi       # 0x4587
callq 0x1060
movq %rsp, %rdi
jmp 0x3db3
leaq 0x86d(%rip), %rdi       # 0x45f7
callq 0x1060
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3dc1
movq 0x8(%rbx), %rsi
leaq 0x787(%rip), %rdi       # 0x4528
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1090
jmp 0x3dc1
leaq 0x818(%rip), %rdi       # 0x45cb
callq 0x1060
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x12ba
movl %ebx, %eax
addq $0x3208, %rsp           # imm = 0x3208
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x242b
movq 0x3d07(%rip), %rax      # 0x61d0
testq %rax, %rax
jle 0x251a
movq 0x3c73(%rip), %rcx      # 0x6148
xorl %r12d, %r12d
movq 0x3af1(%rip), %r14      # 0x5fd0
leaq 0x1b2a(%rip), %r15      # 0x4010
xorl %ebx, %ebx
testq %rcx, %rcx
je 0x24f2
incq %rbx
jmp 0x2510
movl $0x5, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
movq 0x3c3f(%rip), %rcx      # 0x6148
movq 0x3cc0(%rip), %rax      # 0x61d0
incq %r12
cmpq %rax, %r12
jl 0x24e8
jmp 0x251c
xorl %ebx, %ebx
cmpq %rax, %rbx
jne 0x252d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x3a9c(%rip), %r14      # 0x5fd0
leaq 0x1adb(%rip), %rsi      # 0x4016
movl $0x14, %edx
movq %r14, %rdi
callq 0x2170
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rbx
leaq 0x1ace(%rip), %rsi      # 0x402b
movl $0x6, %edx
movq %rax, %rdi
callq 0x2170
movq 0x3c5f(%rip), %rsi      # 0x61d0
movq %rbx, %rdi
callq 0x2140
leaq 0x1b9d(%rip), %rsi      # 0x411d
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2170
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
callq 0x242b
cmpq $0x0, 0x3c27(%rip)      # 0x61d0
jle 0x25dc
xorl %r14d, %r14d
leaq 0x3bb3(%rip), %rbx      # 0x6168
movq %rbx, %rdi
callq 0x21c0
testl %eax, %eax
jne 0x25e4
incq 0x3b80(%rip)            # 0x6148
movq %rbx, %rdi
callq 0x20d0
incq %r14
cmpq 0x3bf6(%rip), %r14      # 0x61d0
jl 0x25b5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0x20b0
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x242b
movq 0x3bce(%rip), %rax      # 0x61d0
testq %rax, %rax
jle 0x266b
xorl %r13d, %r13d
leaq 0x3b57(%rip), %r14      # 0x6168
movq 0x39b8(%rip), %r15      # 0x5fd0
leaq 0x19f1(%rip), %r12      # 0x4010
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x21c0
testl %eax, %eax
jne 0x26ef
movq 0x3b10(%rip), %rbp      # 0x6148
movq %r14, %rdi
callq 0x20d0
testq %rbp, %rbp
je 0x264a
incq %rbx
jmp 0x265a
movl $0x5, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2170
movq 0x3b6f(%rip), %rax      # 0x61d0
incq %r13
cmpq %rax, %r13
jl 0x2621
jmp 0x266d
xorl %ebx, %ebx
cmpq %rax, %rbx
jne 0x2681
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3948(%rip), %r14      # 0x5fd0
leaq 0x1987(%rip), %rsi      # 0x4016
movl $0x14, %edx
movq %r14, %rdi
callq 0x2170
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rbx
leaq 0x197a(%rip), %rsi      # 0x402b
movl $0x6, %edx
movq %rax, %rdi
callq 0x2170
movq 0x3b0b(%rip), %rsi      # 0x61d0
movq %rbx, %rdi
callq 0x2140
leaq 0x1a49(%rip), %rsi      # 0x411d
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2170
movl %eax, %edi
callq 0x20b0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
callq 0x242b
cmpq $0x0, 0x3ac9(%rip)      # 0x61d0
js 0x273a
movq $-0x1, %r14
leaq 0x3a79(%rip), %rbx      # 0x6190
movq %rbx, %rdi
callq 0x21d0
incq 0x3a22(%rip)            # 0x6148
movq %rbx, %rdi
callq 0x21a0
incq %r14
cmpq 0x3a98(%rip), %r14      # 0x61d0
jl 0x2717
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x242b
movq 0x3a77(%rip), %rax      # 0x61d0
testq %rax, %rax
jle 0x27ba
xorl %r13d, %r13d
leaq 0x3a28(%rip), %r14      # 0x6190
movq 0x3861(%rip), %r15      # 0x5fd0
leaq 0x189a(%rip), %r12      # 0x4010
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x21d0
movq 0x39c1(%rip), %rbp      # 0x6148
movq %r14, %rdi
callq 0x21a0
testq %rbp, %rbp
je 0x2799
incq %rbx
jmp 0x27a9
movl $0x5, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2170
movq 0x3a20(%rip), %rax      # 0x61d0
incq %r13
cmpq %rax, %r13
jl 0x2778
jmp 0x27bc
xorl %ebx, %ebx
cmpq %rax, %rbx
jne 0x27d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x37f9(%rip), %r14      # 0x5fd0
leaq 0x1838(%rip), %rsi      # 0x4016
movl $0x14, %edx
movq %r14, %rdi
callq 0x2170
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rbx
leaq 0x182b(%rip), %rsi      # 0x402b
movl $0x6, %edx
movq %rax, %rdi
callq 0x2170
movq 0x39bc(%rip), %rsi      # 0x61d0
movq %rbx, %rdi
callq 0x2140
leaq 0x18fa(%rip), %rsi      # 0x411d
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2170
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x242b
movq 0x397b(%rip), %rax      # 0x61d0
testq %rax, %rax
jle 0x28b6
xorl %r13d, %r13d
leaq 0x392c(%rip), %r14      # 0x6190
movq 0x3765(%rip), %r15      # 0x5fd0
leaq 0x179e(%rip), %r12      # 0x4010
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x2120
movq 0x38c5(%rip), %rbp      # 0x6148
movq %r14, %rdi
callq 0x21a0
testq %rbp, %rbp
je 0x2895
incq %rbx
jmp 0x28a5
movl $0x5, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2170
movq 0x3924(%rip), %rax      # 0x61d0
incq %r13
cmpq %rax, %r13
jl 0x2874
jmp 0x28b8
xorl %ebx, %ebx
cmpq %rax, %rbx
jne 0x28cc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x36fd(%rip), %r14      # 0x5fd0
leaq 0x173c(%rip), %rsi      # 0x4016
movl $0x14, %edx
movq %r14, %rdi
callq 0x2170
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rbx
leaq 0x172f(%rip), %rsi      # 0x402b
movl $0x6, %edx
movq %rax, %rdi
callq 0x2170
movq 0x38c0(%rip), %rsi      # 0x61d0
movq %rbx, %rdi
callq 0x2140
leaq 0x17fe(%rip), %rsi      # 0x411d
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2170
// File: /workspace/github_c_makefile_star2_O3/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 0x242b
cmpq $0x0, 0x3888(%rip)      # 0x61d0
jle 0x2960
xorl %eax, %eax
lock
incq 0x3874(%rip)            # 0x61c8
incq %rax
cmpq 0x3872(%rip), %rax      # 0x61d0
jl 0x294c
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x242b
movq 0x385a(%rip), %rax      # 0x61d0
testq %rax, %rax
jle 0x29c0
xorl %r12d, %r12d
movq 0x364b(%rip), %r14      # 0x5fd0
leaq 0x1684(%rip), %r15      # 0x4010
xorl %ebx, %ebx
movq 0x3833(%rip), %rax      # 0x61c8
testq %rax, %rax
je 0x299f
incq %rbx
jmp 0x29af
movl $0x5, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
movq 0x381a(%rip), %rax      # 0x61d0
incq %r12
cmpq %rax, %r12
jl 0x298e
jmp 0x29c2
xorl %ebx, %ebx
cmpq %rax, %rbx
jne 0x29d3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x35f6(%rip), %r14      # 0x5fd0
leaq 0x1635(%rip), %rsi      # 0x4016
movl $0x14, %edx
movq %r14, %rdi
callq 0x2170
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rbx
leaq 0x1628(%rip), %rsi      # 0x402b
movl $0x6, %edx
movq %rax, %rdi
callq 0x2170
movq 0x37b9(%rip), %rsi      # 0x61d0
movq %rbx, %rdi
callq 0x2140
leaq 0x16f7(%rip), %rsi      # 0x411d
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2170
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
callq 0x242b
movq 0x3785(%rip), %rax      # 0x61d0
testq %rax, %rax
jle 0x2a61
xorl %ecx, %ecx
incq %rcx
movq %rcx, 0x376c(%rip)      # 0x61c8
cmpq %rax, %rcx
jl 0x2a52
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
callq 0x242b
movq 0x3760(%rip), %rax      # 0x61d0
testq %rax, %rax
jle 0x2a89
xorl %ecx, %ecx
incq %rcx
movq %rcx, %rdx
xchgq %rdx, 0x3744(%rip)      # 0x61c8
cmpq %rax, %rcx
jl 0x2a77
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
callq 0x242b
movq 0x3738(%rip), %rax      # 0x61d0
testq %rax, %rax
jle 0x2aae
xorl %ecx, %ecx
incq %rcx
movq %rcx, 0x371f(%rip)      # 0x61c8
cmpq %rax, %rcx
jl 0x2a9f
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x242b
movq 0x35db(%rip), %rax      # 0x61d0
testq %rax, %rax
jle 0x2c3f
xorl %r12d, %r12d
movq 0x33cc(%rip), %r14      # 0x5fd0
leaq 0x142f(%rip), %r15      # 0x403a
xorl %ebx, %ebx
movq 0x35b4(%rip), %rax      # 0x61c8
testq %rax, %rax
je 0x2c1e
incq %rbx
jmp 0x2c2e
movl $0x6, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
movq 0x359b(%rip), %rax      # 0x61d0
incq %r12
cmpq %rax, %r12
jl 0x2c0d
jmp 0x2c41
xorl %ebx, %ebx
cmpq %rax, %rbx
jne 0x2c52
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x3377(%rip), %r14      # 0x5fd0
leaq 0x13b6(%rip), %rsi      # 0x4016
movl $0x14, %edx
movq %r14, %rdi
callq 0x2170
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rbx
leaq 0x13a9(%rip), %rsi      # 0x402b
movl $0x6, %edx
movq %rax, %rdi
callq 0x2170
movq 0x353a(%rip), %rsi      # 0x61d0
movq %rbx, %rdi
callq 0x2140
leaq 0x1478(%rip), %rsi      # 0x411d
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2170
// File: /workspace/github_c_makefile_star2_O3/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_atomic_weak()
void threadfunc_atomic_weak()
    {
      start_wait();
      // Wait until main() sends data
      long i;
      uint64_t next;
      for (i = 1; i <= count; i++) {
        do {
          next = atomic_uint.load(std::memory_order_relaxed);
        }
        while (!atomic_uint.compare_exchange_weak(next,
                                                  next + 1,
                                                  std::memory_order_release,
                                                  std::memory_order_relaxed));
      }
    }

// Assembly:
pushq %rax
callq 0x242b
cmpq $0x0, 0x3505(%rip)      # 0x61d0
jle 0x2cf8
movl $0x1, %ecx
movq 0x34ef(%rip), %rax      # 0x61c8
leaq 0x1(%rax), %rdx
lock
cmpxchgq %rdx, 0x34e2(%rip)      # 0x61c8
jne 0x2cd2
leaq 0x1(%rcx), %rax
cmpq 0x34dd(%rip), %rcx      # 0x61d0
movq %rax, %rcx
jl 0x2cd2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0xa36e
testq %rsi, %rsi
je 0xa38d
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
popq %rbp
retq
leaq 0x22c8f(%rip), %rdi     # 0x2d004
leaq 0x22c8d(%rip), %rsi     # 0x2d009
leaq 0x22c8e(%rip), %rcx     # 0x2d011
movl $0xf, %edx
callq 0xa0b0
leaq 0x22ca6(%rip), %rdi     # 0x2d03a
leaq 0x22c6e(%rip), %rsi     # 0x2d009
leaq 0x22c6f(%rip), %rcx     # 0x2d011
movl $0x10, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa3d9
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xa3c8
callq 0xa1a0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x22c24(%rip), %rdi     # 0x2d004
leaq 0x22c22(%rip), %rsi     # 0x2d009
leaq 0x22c5a(%rip), %rcx     # 0x2d048
movl $0x19, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa45d
movq %rsi, %r15
testq %rsi, %rsi
je 0xa47c
movq %rdx, %rbx
testq %rdx, %rdx
je 0xa452
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq (%rdi,%rbx), %rax
cmpq (%r14), %rax
jbe 0xa436
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa49b
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rdx
imulq %rdx, %rdi
addq 0x18(%r14), %rdi
imulq %rbx, %rdx
movq %r15, %rsi
callq 0xa120
addq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22c05(%rip), %rdi     # 0x2d069
leaq 0x22b9e(%rip), %rsi     # 0x2d009
leaq 0x22bfb(%rip), %rcx     # 0x2d06d
movl $0x39, %edx
callq 0xa0b0
leaq 0x24a5a(%rip), %rdi     # 0x2eedd
leaq 0x22b7f(%rip), %rsi     # 0x2d009
leaq 0x22bdc(%rip), %rcx     # 0x2d06d
movl $0x3a, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq %rsi, %rsi
addq (%rdi), %rsi
movq %rsi, (%rdi)
movq 0x18(%rdi), %rdi
imulq 0x10(%rbx), %rsi
testq %rdi, %rdi
je 0xa4c2
callq 0xa140
jmp 0xa4ca
movq %rsi, %rdi
callq 0xa130
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0xa4fb
testq %rsi, %rsi
je 0xa51a
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0xa539
movq 0x8(%rsi), %rdx
movq 0x18(%rsi), %rsi
popq %rbp
jmp 0xa3f8
leaq 0x22b67(%rip), %rdi     # 0x2d069
leaq 0x22b00(%rip), %rsi     # 0x2d009
leaq 0x22b99(%rip), %rcx     # 0x2d0a9
movl $0x4c, %edx
callq 0xa0b0
leaq 0x249bc(%rip), %rdi     # 0x2eedd
leaq 0x22ae1(%rip), %rsi     # 0x2d009
leaq 0x22b7a(%rip), %rcx     # 0x2d0a9
movl $0x4d, %edx
callq 0xa0b0
leaq 0x22ba8(%rip), %rdi     # 0x2d0e8
leaq 0x22ac2(%rip), %rsi     # 0x2d009
leaq 0x22b5b(%rip), %rcx     # 0x2d0a9
movl $0x4e, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xa5f0
movq %rsi, %r12
testq %rsi, %rsi
je 0xa60f
movq %rdx, %rbx
testq %rdx, %rdx
je 0xa5e7
movq %rcx, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdx
leaq (%rdx,%rbx), %rax
cmpq (%rdi), %rax
jbe 0xa5a2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa49b
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rax
leaq (%r15,%rbx), %rdi
imulq %rsi, %rdi
addq %rax, %rdi
subq %r15, %rdx
imulq %rsi, %rdx
imulq %r15, %rsi
addq %rax, %rsi
callq 0xa120
movq 0x10(%r14), %rdx
imulq %rdx, %r15
addq 0x18(%r14), %r15
imulq %rbx, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0xa120
addq %rbx, 0x8(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22a72(%rip), %rdi     # 0x2d069
leaq 0x22a0b(%rip), %rsi     # 0x2d009
leaq 0x22b04(%rip), %rcx     # 0x2d109
movl $0x59, %edx
callq 0xa0b0
leaq 0x248c7(%rip), %rdi     # 0x2eedd
leaq 0x229ec(%rip), %rsi     # 0x2d009
leaq 0x22ae5(%rip), %rcx     # 0x2d109
movl $0x5a, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/lexer.c
// Function: lexer_new_context
LexerContext * lexer_new_context(
	const char *file,
	const char *source,
	int len,
	LexerTokenMatcher *matchers
) {
	assert(file);
	assert(source);
	assert(len >= 0);
	assert(matchers[0].name != NULL);

	LexerContext *ctx = (LexerContext *)malloc(sizeof(LexerContext));
	if (ctx == NULL) {
		return NULL;
	}

	ctx->file = file;
	rarr_init(&(ctx->rarr_file), sizeof(char *));
	
	ctx->source = source;
	ctx->len = len;
	ctx->index = -1;
	ctx->line = 1;
	ctx->column = 0;

	ctx->stored_index = -1;
	ctx->stored_line = 1;
	ctx->stored_column = 0;

	ctx->head = NULL;
	ctx->tail = NULL;
	ctx->current = NULL;

	ctx->tokens = NULL;

	ctx->curstack_top = -1;

	ctx->matchers = matchers;

	ctx->data = NULL;

	ctx->invalid_token = _default_invalid_token;
	ctx->alloc_mem_error = _default_alloc_mem_error;

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xaef9
movq %rsi, %r15
testq %rsi, %rsi
je 0xaf18
movl %edx, %r14d
testl %edx, %edx
js 0xaf37
movq %rcx, %rbx
cmpq $0x0, (%rcx)
je 0xaf56
movq %rdi, %r13
movl $0x2098, %edi           # imm = 0x2098
callq 0xa130
movq %rax, %r12
testq %rax, %rax
je 0xaee7
movq %r13, (%r12)
movq %r12, %rdi
addq $0x8, %rdi
movl $0x8, %esi
callq 0xa34c
movq %r15, 0x28(%r12)
movl %r14d, 0x30(%r12)
movaps 0x22642(%rip), %xmm0    # 0x2d4d0
movups %xmm0, 0x34(%r12)
movq $0x1, 0x44(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r12)
movups %xmm0, 0x60(%r12)
movl $0xffffffff, 0x70(%r12) # imm = 0xFFFFFFFF
movq %rbx, 0x2078(%r12)
movq $0x0, 0x2080(%r12)
leaq 0xa5(%rip), %rax        # 0xaf75
movq %rax, 0x2088(%r12)
leaq 0x1b8(%rip), %rax       # 0xb097
movq %rax, 0x2090(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22b09(%rip), %rdi     # 0x2da09
leaq 0x280b0(%rip), %rsi     # 0x32fb7
leaq 0x225d2(%rip), %rcx     # 0x2d4e0
movl $0x67, %edx
callq 0xa0b0
leaq 0x22617(%rip), %rdi     # 0x2d536
leaq 0x28091(%rip), %rsi     # 0x32fb7
leaq 0x225b3(%rip), %rcx     # 0x2d4e0
movl $0x68, %edx
callq 0xa0b0
leaq 0x225ff(%rip), %rdi     # 0x2d53d
leaq 0x28072(%rip), %rsi     # 0x32fb7
leaq 0x22594(%rip), %rcx     # 0x2d4e0
movl $0x69, %edx
callq 0xa0b0
leaq 0x22922(%rip), %rdi     # 0x2d87f
leaq 0x28053(%rip), %rsi     # 0x32fb7
leaq 0x22575(%rip), %rcx     # 0x2d4e0
movl $0x6a, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb059
movq %rdi, %rbx
movq (%rdi), %rdx
testq %rdx, %rdx
je 0xb078
movq 0x34056(%rip), %r14     # 0x3eff8
movq (%r14), %rdi
movl 0x38(%rbx), %ecx
movl 0x3c(%rbx), %r8d
leaq 0x22a5b(%rip), %rsi     # 0x2da0e
xorl %r12d, %r12d
xorl %eax, %eax
callq 0xa100
movq (%r14), %rsi
movl $0xa, %edi
callq 0xa0d0
movq (%r14), %rsi
movl $0x9, %edi
callq 0xa0d0
movb $0x1, %r13b
movslq 0x34(%rbx), %rax
leal (%r12,%rax), %ecx
cmpl 0x30(%rbx), %ecx
jge 0xb02e
addq 0x28(%rbx), %rax
movsbq (%r12,%rax), %r14
callq 0xa190
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
sete %r15b
je 0xb010
movl $0x20, %r14d
testb $0x1, %r13b
je 0xb022
movq 0x33fe1(%rip), %rax     # 0x3eff8
movq (%rax), %rsi
movl %r14d, %edi
callq 0xa0d0
incq %r12
movl %r15d, %r13d
cmpl $0x3c, %r12d
jne 0xafda
movq 0x33fc3(%rip), %rbx     # 0x3eff8
movq (%rbx), %rsi
movl $0xa, %edi
callq 0xa0d0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0xa0d0
movl $0x1, %edi
callq 0xa170
leaq 0x24d64(%rip), %rdi     # 0x2fdc4
leaq 0x27f50(%rip), %rsi     # 0x32fb7
leaq 0x2296a(%rip), %rcx     # 0x2d9d8
movl $0x39, %edx
callq 0xa0b0
leaq 0x22985(%rip), %rdi     # 0x2da04
leaq 0x27f31(%rip), %rsi     # 0x32fb7
leaq 0x2294b(%rip), %rcx     # 0x2d9d8
movl $0x3a, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
jne 0xb0bf
leaq 0x24d1d(%rip), %rdi     # 0x2fdc4
leaq 0x27f09(%rip), %rsi     # 0x32fb7
leaq 0x22986(%rip), %rcx     # 0x2da3b
movl $0x59, %edx
callq 0xa0b0
movq (%rdi), %rdx
testq %rdx, %rdx
jne 0xb0e6
leaq 0x22936(%rip), %rdi     # 0x2da04
leaq 0x27ee2(%rip), %rsi     # 0x32fb7
leaq 0x2295f(%rip), %rcx     # 0x2da3b
movl $0x5a, %edx
callq 0xa0b0
movq 0x33f0b(%rip), %rax     # 0x3eff8
movq (%rax), %rax
movl 0x38(%rdi), %ecx
movl 0x3c(%rdi), %r8d
leaq 0x2296b(%rip), %rsi     # 0x2da69
movq %rax, %rdi
xorl %eax, %eax
callq 0xa100
movl $0x1, %edi
callq 0xa170
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xb178
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0xb149
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq 0x18(%rbx), %rcx
imulq %r14, %rcx
movq (%rax,%rcx), %rdi
callq 0xa1a0
incq %r14
cmpq %r14, 0x10(%rbx)
ja 0xb12b
leaq 0x8(%rbx), %rdi
callq 0xa3ac
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0xb16c
movq 0x30(%rdi), %r14
callq 0xa1a0
movq %r14, %rdi
testq %r14, %r14
jne 0xb15b
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa1a0
leaq 0x24c45(%rip), %rdi     # 0x2fdc4
leaq 0x27e31(%rip), %rsi     # 0x32fb7
leaq 0x223b9(%rip), %rcx     # 0x2d546
movl $0x91, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xb22c
movslq 0x34(%rdi), %rax
incq %rax
movl 0x30(%rdi), %ecx
cmpl %ecx, %eax
jge 0xb21f
movl %eax, 0x34(%rdi)
movq 0x28(%rdi), %rcx
movsbl (%rcx,%rax), %eax
cmpl $0xa, %eax
jne 0xb228
incl 0x38(%rdi)
movl $0x0, 0x3c(%rdi)
movl $0xa, %eax
retq
movl %ecx, 0x34(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
incl 0x3c(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x24b8d(%rip), %rdi     # 0x2fdc4
leaq 0x27d79(%rip), %rsi     # 0x32fb7
leaq 0x22329(%rip), %rcx     # 0x2d56e
movl $0xa6, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xb2b3
movq %rsi, %rbx
testq %rsi, %rsi
je 0xb2d2
movq %rdi, %r14
movq %rbx, %rdi
callq 0xa080
xorl %esi, %esi
movq %rsi, %rcx
cmpq %rsi, %rax
je 0xb2a8
movl 0x34(%r14), %edx
leaq (%rcx,%rdx), %rsi
incq %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
testl %esi, %esi
js 0xb29c
cmpl 0x30(%r14), %esi
jge 0xb29c
movq 0x28(%r14), %rdx
movl %esi, %esi
movsbl (%rdx,%rsi), %edx
movsbl (%rbx,%rcx), %edi
leaq 0x1(%rcx), %rsi
cmpl %edi, %edx
je 0xb270
cmpq %rcx, %rax
setbe %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x24b0a(%rip), %rdi     # 0x2fdc4
leaq 0x27cf6(%rip), %rsi     # 0x32fb7
leaq 0x222ca(%rip), %rcx     # 0x2d592
movl $0xbc, %edx
callq 0xa0b0
leaq 0x237d2(%rip), %rdi     # 0x2eaab
leaq 0x27cd7(%rip), %rsi     # 0x32fb7
leaq 0x222ab(%rip), %rcx     # 0x2d592
movl $0xbd, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xb310
addl 0x34(%rdi), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
js 0xb30f
cmpl 0x30(%rdi), %esi
jge 0xb30f
movq 0x28(%rdi), %rax
movl %esi, %ecx
movsbl (%rax,%rcx), %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x24aa9(%rip), %rdi     # 0x2fdc4
leaq 0x27c95(%rip), %rsi     # 0x32fb7
leaq 0x222a0(%rip), %rcx     # 0x2d5c9
movl $0xca, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xb383
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0xb382
movq 0x28(%rax), %rcx
movq %rcx, 0x60(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x24a36(%rip), %rdi     # 0x2fdc4
leaq 0x27c22(%rip), %rsi     # 0x32fb7
leaq 0x22282(%rip), %rcx     # 0x2d61e
movl $0xe2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xb3c0
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0xb3bd
movq 0x20(%rax), %rax
movq %rax, 0x60(%rdi)
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x249f9(%rip), %rdi     # 0x2fdc4
leaq 0x27be5(%rip), %rsi     # 0x32fb7
leaq 0x22272(%rip), %rcx     # 0x2d64b
movl $0xee, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/lexer.c
// Function: lexer_init_token
void lexer_init_token(LexerContext *ctx, LexerToken *token, int type) {
	assert(ctx);
	assert(token);
	
	token->type = type;

	token->len = 1;
	token->content = ctx->source + ctx->index;

	token->file = ctx->file;
	token->line = ctx->line;
	token->column = ctx->column;

	token->prev = NULL;
	token->next = NULL;

	token->matcher_data = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xb457
testq %rsi, %rsi
je 0xb476
movl %edx, (%rsi)
movl $0x1, 0x4(%rsi)
movslq 0x34(%rdi), %rax
addq 0x28(%rdi), %rax
movq %rax, 0x8(%rsi)
movq (%rdi), %rax
movq %rax, 0x10(%rsi)
movl 0x38(%rdi), %eax
movl %eax, 0x18(%rsi)
movl 0x3c(%rdi), %eax
movl %eax, 0x1c(%rsi)
movq $0x0, 0x38(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsi)
popq %rbp
retq
leaq 0x24966(%rip), %rdi     # 0x2fdc4
leaq 0x27b52(%rip), %rsi     # 0x32fb7
leaq 0x22245(%rip), %rcx     # 0x2d6b1
movl $0x103, %edx            # imm = 0x103
callq 0xa0b0
leaq 0x2203d(%rip), %rdi     # 0x2d4ba
leaq 0x27b33(%rip), %rsi     # 0x32fb7
leaq 0x22226(%rip), %rcx     # 0x2d6b1
movl $0x104, %edx            # imm = 0x104
callq 0xa0b0