LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/BLAKE2/blake2b-optimized.h
// Function: blake2b_init_param
static int blake2b_init_param( blake2b_state *S, const blake2b_param *P )
{
  size_t i;
  /*blake2b_init0( S ); */
  const unsigned char * v = ( const unsigned char * )( blake2b_IV );
  const unsigned char * p = ( const unsigned char * )( P );
  unsigned char * h = ( unsigned char * )( S->h );
  /* IV XOR ParamBlock */
  memset( S, 0, sizeof( blake2b_state ) );

  for( i = 0; i < BLAKE2B_OUTBYTES; ++i ) h[i] = v[i] ^ p[i];

  S->outlen = P->digest_length;
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x152eb(%rip), %rax     # 0x25080
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0xf8, %edx
callq 0x2170
movq $0x0, 0x20(%rsp)
cmpq $0x40, 0x20(%rsp)
jae 0xfe0d
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xfdc8
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movq %rcx, 0xe8(%rax)
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/BLAKE2/blake2b-optimized.h
// Function: blake2b_update
int blake2b_update( blake2b_state *S, const void *pin, size_t inlen )
{
  const unsigned char * in = (const unsigned char *)pin;
  if( inlen > 0 )
  {
    size_t left = S->buflen;
    size_t fill = BLAKE2B_BLOCKBYTES - left;
    if( inlen > fill )
    {
      S->buflen = 0;
      memcpy( S->buf + left, in, fill ); /* Fill buffer */
      blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
      blake2b_compress( S, S->buf ); /* Compress */
      in += fill; inlen -= fill;
      while(inlen > BLAKE2B_BLOCKBYTES) {
        blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
        blake2b_compress( S, in );
        in += BLAKE2B_BLOCKBYTES;
        inlen -= BLAKE2B_BLOCKBYTES;
      }
    }
    memcpy( S->buf + S->buflen, in, inlen );
    S->buflen += inlen;
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jbe 0xff82
movq 0x30(%rsp), %rax
movq 0xe0(%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x80, %eax
subq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0xff46
movq 0x30(%rsp), %rax
movq $0x0, 0xe0(%rax)
movq 0x30(%rsp), %rdi
addq $0x60, %rdi
addq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2250
movq 0x30(%rsp), %rdi
movl $0x80, %esi
callq 0xff90
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x60, %rsi
callq 0xffe0
movq 0x8(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x20(%rsp)
cmpq $0x80, 0x20(%rsp)
jbe 0xff44
movq 0x30(%rsp), %rdi
movl $0x80, %esi
callq 0xff90
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xffe0
movq 0x18(%rsp), %rax
addq $0x80, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
subq $0x80, %rax
movq %rax, 0x20(%rsp)
jmp 0xfef9
jmp 0xff46
movq 0x30(%rsp), %rdi
addq $0x60, %rdi
movq 0x30(%rsp), %rax
addq 0xe0(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x2250
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
addq 0xe0(%rax), %rcx
movq %rcx, 0xe0(%rax)
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/BLAKE2/blake2b-optimized.h
// Function: blake2b_final
int blake2b_final( blake2b_state *S, void *out, size_t outlen )
{
  if( out == NULL || outlen < S->outlen )
    return -1;

  if( blake2b_is_lastblock( S ) )
    return -1;

  blake2b_increment_counter( S, S->buflen );
  blake2b_set_lastblock( S );
  memset( S->buf + S->buflen, 0, BLAKE2B_BLOCKBYTES - S->buflen ); /* Padding */
  blake2b_compress( S, S->buf );

  memcpy( out, &S->h[0], S->outlen );
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2201e
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0xe8(%rcx), %rax
jae 0x2202b
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x220ca
movq 0x18(%rsp), %rdi
callq 0x220e0
cmpl $0x0, %eax
je 0x22047
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x220ca
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xe0(%rax), %rsi
callq 0xff90
movq 0x18(%rsp), %rdi
callq 0x22100
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
movq 0x18(%rsp), %rax
addq 0xe0(%rax), %rdi
movq 0x18(%rsp), %rax
movl $0x80, %edx
subq 0xe0(%rax), %rdx
xorl %esi, %esi
callq 0x2170
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x60, %rsi
callq 0xffe0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xe8(%rax), %rdx
callq 0x2250
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/BLAKE2/blake2-impl.h
// Function: load64
static BLAKE2_INLINE uint64_t load64( const void *src )
{
#if defined(NATIVE_LITTLE_ENDIAN)
  uint64_t w;
  memcpy(&w, src, sizeof w);
  return w;
#else
  const uint8_t *p = ( const uint8_t * )src;
  return (( uint64_t )( p[0] ) <<  0) |
         (( uint64_t )( p[1] ) <<  8) |
         (( uint64_t )( p[2] ) << 16) |
         (( uint64_t )( p[3] ) << 24) |
         (( uint64_t )( p[4] ) << 32) |
         (( uint64_t )( p[5] ) << 40) |
         (( uint64_t )( p[6] ) << 48) |
         (( uint64_t )( p[7] ) << 56) ;
#endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
shlq $0x0, %rax
movq -0x10(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
shlq $0x8, %rcx
orq %rcx, %rax
movq -0x10(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
shlq $0x10, %rcx
orq %rcx, %rax
movq -0x10(%rsp), %rcx
movzbl 0x3(%rcx), %ecx
shlq $0x18, %rcx
orq %rcx, %rax
movq -0x10(%rsp), %rcx
movzbl 0x4(%rcx), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq -0x10(%rsp), %rcx
movzbl 0x5(%rcx), %ecx
shlq $0x28, %rcx
orq %rcx, %rax
movq -0x10(%rsp), %rcx
movzbl 0x6(%rcx), %ecx
shlq $0x30, %rcx
orq %rcx, %rax
movq -0x10(%rsp), %rcx
movzbl 0x7(%rcx), %ecx
shlq $0x38, %rcx
orq %rcx, %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/CRegion/alloc-growable.c
// Function: CR_RegionAllocGrowable
void *CR_RegionAllocGrowable(CR_Region *r, size_t size)
{
  if(size == 0)
  {
    CR_ExitFailure("unable to allocate 0 bytes");
  }

  CR_StaticAssert(sizeof(Header) % 8 == 0);
  const size_t chunk_size = CR_SafeAdd(sizeof(Header), size);

  void **attached_pointer = CR_RegionAlloc(r, sizeof *attached_pointer);

  Header *header = malloc(chunk_size);
  if(header == NULL)
  {
    CR_ExitFailure("failed to allocate %zu bytes", chunk_size);
  }

  *attached_pointer = header;
  header->attached_pointer = attached_pointer;
  header->capacity = size;

  CR_RegionAttach(r, freeAttachedPointer, attached_pointer);

  ASAN_POISON_MEMORY_REGION(header, sizeof(Header));
  return header + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x229e5
leaq 0x1636(%rip), %rdi      # 0x24014
movb $0x0, %al
callq 0x4680
jmp 0x229e7
jmp 0x229e9
movq -0x10(%rbp), %rsi
movl $0x10, %edi
callq 0x234c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x230e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x22a33
movq -0x18(%rbp), %rsi
leaq 0x1612(%rip), %rdi      # 0x2403e
movb $0x0, %al
callq 0x4680
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x1c(%rip), %rsi        # 0x22a80
callq 0x232e0
movq -0x28(%rbp), %rax
addq $0x10, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/CRegion/alloc-growable.c
// Function: CR_EnsureCapacity
void *CR_EnsureCapacity(void *ptr, size_t size)
{
  if(size == 0)
  {
    CR_ExitFailure("unable to allocate 0 bytes");
  }
  else if(ptr == NULL)
  {
    return CR_RegionAllocGrowable(CR_GetGlobalRegion(), size);
  }

  Header *header = (Header *)ptr - 1;
  ASAN_UNPOISON_MEMORY_REGION(header, sizeof(Header));
  if(size <= header->capacity)
  {
    ASAN_POISON_MEMORY_REGION(header, sizeof(Header));
    return ptr;
  }

  const size_t chunk_size = CR_SafeAdd(sizeof(Header), size);
  Header *reallocated_header = realloc(header, chunk_size);
  if(reallocated_header == NULL)
  {
    CR_ExitFailure("failed to reallocate %zu bytes", chunk_size);
  }

  *reallocated_header->attached_pointer = reallocated_header;
  reallocated_header->capacity = size;

  ASAN_POISON_MEMORY_REGION(reallocated_header, sizeof(Header));
  return reallocated_header + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x22ad5
leaq 0x1546(%rip), %rdi      # 0x24014
movb $0x0, %al
callq 0x4680
cmpq $0x0, -0x10(%rbp)
jne 0x22af6
callq 0x22b90
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x229c0
movq %rax, -0x8(%rbp)
jmp 0x22b7e
jmp 0x22af8
movq -0x10(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x22b1c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x22b7e
movq -0x18(%rbp), %rsi
movl $0x10, %edi
callq 0x234c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2300
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x22b58
movq -0x28(%rbp), %rsi
leaq 0x258f(%rip), %rdi      # 0x250e0
movb $0x0, %al
callq 0x4680
movq -0x30(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/CRegion/mempool.c
// Function: CR_MempoolNew
CR_Mempool *CR_MempoolNew(CR_Region *r, size_t object_size,
                          CR_FailableDestructor *explicit_destructor,
                          CR_ReleaseCallback *implicit_destructor)
{
  if(object_size == 0)
  {
    CR_ExitFailure("unable to create memory pool for allocating zero size objects");
  }
  CR_StaticAssert(sizeof(Header) % 8 == 0);

  CR_Mempool *mp = CR_RegionAlloc(r, sizeof *mp);
  mp->r = r;
  mp->explicit_destructor = explicit_destructor;
  mp->implicit_destructor = implicit_destructor;
  mp->chunk_size = CR_SafeAdd(sizeof(Header), object_size);
  mp->allocated_chunks = NULL;
  mp->released_chunks = NULL;
  CR_RegionAttach(r, destroyObjects, mp);

  return mp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x22bed
leaq 0x251a(%rip), %rdi      # 0x25100
movb $0x0, %al
callq 0x4680
jmp 0x22bef
jmp 0x22bf1
movq -0x8(%rbp), %rdi
movl $0x30, %esi
callq 0x230e0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rsi
movl $0x20, %edi
callq 0x234c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1a(%rip), %rsi        # 0x22c80
callq 0x232e0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/CRegion/mempool.c
// Function: destroyObjects
static void destroyObjects(void *data)
{
  CR_Mempool *mp = data;
  if(mp->implicit_destructor == NULL)
  {
    FREE_ALL_CHUNKS_IF_REQUIRED(mp);
    return;
  }

  for(Header *header = mp->allocated_chunks;
      header != NULL; header = header->next)
  {
    ASAN_UNPOISON_MEMORY_REGION(header, sizeof(Header));
    if(header->destructor_state == DS_enabled)
    {
      ASAN_POISON_MEMORY_REGION(header, sizeof(Header));
      mp->implicit_destructor(header + 1);
      ASAN_UNPOISON_MEMORY_REGION(header, sizeof(Header));
    }
  }

  FREE_ALL_CHUNKS_IF_REQUIRED(mp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x22ca1
jmp 0x22cdf
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x22cdf
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x22ccf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq *%rax
jmp 0x22cd1
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x22cad
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/CRegion/mempool.c
// Function: CR_MempoolAlloc
void *CR_MempoolAlloc(CR_Mempool *mp)
{
  Header *header = getAvailableChunk(mp);

  header->destructor_state = DS_disabled;
  header->mp = mp;
  header->prev = NULL;

  /* Prepend header to the mempools allocated chunk list. */
  header->next = mp->allocated_chunks;
  mp->allocated_chunks = header;

  if(header->next != NULL)
  {
    ASAN_UNPOISON_MEMORY_REGION(header->next, sizeof(Header));
    header->next->prev = header;
    ASAN_POISON_MEMORY_REGION(header->next, sizeof(Header));
  }

  ASAN_POISON_MEMORY_REGION(header, sizeof(Header));
  return header + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22d70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x22d62
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/CRegion/mempool.c
// Function: getAvailableChunk
static void *getAvailableChunk(CR_Mempool *mp)
{
#ifdef CREGION_ALWAYS_FRESH_MALLOC
  void *data = malloc(mp->chunk_size);
  if(data == NULL)
  {
    CR_ExitFailure("failed to allocate %zu bytes", mp->chunk_size);
  }

  return data;
#else
  if(mp->released_chunks == NULL)
  {
    return CR_RegionAlloc(mp->r, mp->chunk_size);
  }
  else
  {
    void *chunk = mp->released_chunks;
    ASAN_UNPOISON_MEMORY_REGION(mp->released_chunks, mp->chunk_size);

    mp->released_chunks = mp->released_chunks->next;
    if(mp->released_chunks != NULL)
    {
      ASAN_UNPOISON_MEMORY_REGION(mp->released_chunks, sizeof(Header));
      mp->released_chunks->prev = NULL;
      ASAN_POISON_MEMORY_REGION(mp->released_chunks, sizeof(Header));
    }

    return chunk;
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x22da1
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x230e0
movq %rax, -0x8(%rbp)
jmp 0x22de4
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x22ddc
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/CRegion/region.c
// Function: CR_RegionNew
CR_Region *CR_RegionNew(void)
{
  ensureRegionsAreInitialized();
  CR_StaticAssert(alignment == 8);
  CR_StaticAssert(sizeof(CR_Region) % alignment == 0);
  CR_StaticAssert(sizeof(ChunkList) % alignment == 0);
  CR_StaticAssert(first_chunk_size/2 % alignment == 0);
  CR_StaticAssert(sizeof(ChunkList) + sizeof(CR_Region) < first_chunk_size/2);

  /* The region and its chunk-list are part of the first chunk. */
  ChunkList *element = checkedMalloc(first_chunk_size);
  CR_Region *r = (CR_Region *)(element + 1);

  r->aligned.chunk = (unsigned char *)element;
  r->aligned.bytes_used = (sizeof *element) + (sizeof *r);
  r->aligned.capacity = first_chunk_size/2;
  r->aligned.next_chunk_size = first_chunk_size * 2;

  r->unaligned.chunk = &r->aligned.chunk[first_chunk_size/2];
  r->unaligned.bytes_used = 0;
  r->unaligned.capacity = first_chunk_size/2;
  r->unaligned.next_chunk_size = first_chunk_size * 2;

  r->chunk_list = element;
  r->chunk_list->next = NULL;

  r->callback_list = NULL;
  r->pending_callback = NULL;
  r->pending_callback_data = NULL;

  /* Prepend region to region list. */
  r->prev = NULL;
  r->next = region_list;

  if(region_list != NULL)
  {
    region_list->prev = r;
  }
  region_list = r;

  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x23060
jmp 0x22f3f
jmp 0x22f41
jmp 0x22f43
jmp 0x22f45
jmp 0x22f47
jmp 0x22f49
jmp 0x22f4b
jmp 0x22f4d
jmp 0x22f4f
movl $0x400, %edi            # imm = 0x400
callq 0x230a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x78, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x200, 0x10(%rax)      # imm = 0x200
movq -0x10(%rbp), %rax
movq $0x800, 0x18(%rax)      # imm = 0x800
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x200, %rcx            # imm = 0x200
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x200, 0x30(%rax)      # imm = 0x200
movq -0x10(%rbp), %rax
movq $0x800, 0x38(%rax)      # imm = 0x800
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq 0x62b4(%rip), %rcx      # 0x292d8
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
cmpq $0x0, 0x62a4(%rip)      # 0x292d8
je 0x23045
movq -0x10(%rbp), %rcx
movq 0x6297(%rip), %rax      # 0x292d8
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x6288(%rip)      # 0x292d8
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/CRegion/region.c
// Function: ensureRegionsAreInitialized
static void ensureRegionsAreInitialized(void)
{
  static bool initialized = false;
  if(initialized == true)
  {
    return;
  }

  if(atexit(releaseAllRegions) != 0)
  {
    CR_ExitFailure("failed to register function with atexit");
  }

  initialized = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x6276(%rip), %al       # 0x292e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x23076
jmp 0x2309c
leaq 0x3e3(%rip), %rdi       # 0x23460
callq 0x23560
cmpl $0x0, %eax
je 0x23095
leaq 0x19df(%rip), %rdi      # 0x24a6d
movb $0x0, %al
callq 0x4680
movb $0x1, 0x6244(%rip)      # 0x292e0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/CRegion/region.c
// Function: checkedMalloc
static void *checkedMalloc(size_t size)
{
  void *data = malloc(size);
  if(data == NULL)
  {
    CR_ExitFailure("failed to allocate %zu bytes", size);
  }

  return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x230d2
movq -0x8(%rbp), %rsi
leaq 0xf73(%rip), %rdi       # 0x2403e
movb $0x0, %al
callq 0x4680
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/CRegion/region.c
// Function: allocFromChunk
static void *allocFromChunk(CR_Region *r, Chunk *chunk, size_t size)
{
  if(size == 0)
  {
    CR_ExitFailure("unable to allocate 0 bytes");
  }

  if(size <= chunk->capacity - chunk->bytes_used)
  {
    return popBytesFromChunk(chunk, size);
  }
  else if(size < chunk->next_chunk_size - sizeof(ChunkList))
  {
    ChunkList *element = checkedMalloc(chunk->next_chunk_size);

    chunk->chunk = (unsigned char *)element;
    chunk->bytes_used = sizeof *element;
    chunk->capacity = chunk->next_chunk_size;

    element->next = r->chunk_list;
    r->chunk_list = element;

    chunk->next_chunk_size = CR_SafeMultiply(chunk->next_chunk_size, 2);

    return popBytesFromChunk(chunk, size);
  }
  else
  {
    ChunkList *element = checkedMalloc(CR_SafeAdd(sizeof(ChunkList), size));

    element->next = r->chunk_list;
    r->chunk_list = element;

    return element + 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x231c9
leaq 0xe52(%rip), %rdi       # 0x24014
movb $0x0, %al
callq 0x4680
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
subq 0x8(%rdx), %rcx
cmpq %rcx, %rax
ja 0x231f8
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x23480
movq %rax, -0x8(%rbp)
jmp 0x232d5
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x8, %rcx
cmpq %rcx, %rax
jae 0x23294
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x230a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x8, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x23500
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x23480
movq %rax, -0x8(%rbp)
jmp 0x232d5
movq -0x20(%rbp), %rsi
movl $0x8, %edi
callq 0x234c0
movq %rax, %rdi
callq 0x230a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/CRegion/region.c
// Function: CR_RegionAttach
void CR_RegionAttach(CR_Region *r, CR_ReleaseCallback *callback, void *data)
{
  /* Store the callback inside the region as the current pending
     callback. This is required in case the following allocation
     fails and terminates the program. */
  r->pending_callback = callback;
  r->pending_callback_data = data;

  CallbackList *element = allocFromChunkWithPadding(r, sizeof *element);

  r->pending_callback = NULL;
  r->pending_callback_data = NULL;

  /* Prepend the callback to the regions callback-list. */
  element->callback = callback;
  element->data = data;

  element->next = r->callback_list;
  r->callback_list = element;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rdi
movl $0x18, %esi
callq 0x23110
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlxHnr[P]nano-backup/third-party/CRegion/region.c
// Function: CR_RegionRelease
void CR_RegionRelease(CR_Region *r)
{
  /* Call all attached callbacks. */
  if(r->pending_callback != NULL)
  {
    r->pending_callback(r->pending_callback_data);
  }
  for(CallbackList *element = r->callback_list;
      element != NULL; element = element->next)
  {
    element->callback(element->data);
  }

  /* Detach the region from the region-list. */
  if(r->prev != NULL)
  {
    r->prev->next = r->next;
  }
  if(r->next != NULL)
  {
    r->next->prev = r->prev;
  }
  if(r == region_list)
  {
    region_list = region_list->next;
  }

  /* Free all chunks associated with the region. */
  ChunkList *element = r->chunk_list;
  while(element != NULL)
  {
    ChunkList *next = element->next;
    free(element);
    element = next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x23399
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x233cb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x233a5
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x233ea
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x23409
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
cmpq 0x5ec4(%rip), %rax      # 0x292d8
jne 0x23428
movq 0x5ebb(%rip), %rax      # 0x292d8
movq 0x68(%rax), %rax
movq %rax, 0x5eb0(%rip)      # 0x292d8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x23459
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2040
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x23434
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshasm.c
// Function: readsetCreate
Readset *readsetCreate (Moshset *ms, int n) /* create empty - n is used to initialise arrays */
{
  Readset *rs = new0 (1, Readset) ;
  rs->ms = ms ;
  rs->reads = arrayCreate (n, Read) ;
  arrayp(rs->reads,0,Read)->nHit = 0 ; /* burn first read, so can use 0 as null */
  /* create inv, invSpace in invBuild() */
  return rs ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0xa230
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %edi
movl $0x48, %esi
callq 0x9220
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x9680
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshasm.c
// Function: readsetDestroy
void readsetDestroy (Readset *rs)
{
  int i, n = arrayMax(rs->reads) ; Read *r = arrp(rs->reads,0,Read) ;
  for (i = 0 ; i < n ; ++i, ++r) if (r->nHit) { free(r->hit) ; free(r->dx) ; }
  arrayDestroy (rs->reads) ;
  if (rs->inv) { free (rs->inv) ; free (rs->invSpace) ; }
  free (rs) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
imull $0x0, 0x14(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1458
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x143f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1040
jmp 0x1441
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x18(%rbp)
jmp 0x1413
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x9420
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x148a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshasm.c
// Function: badOverlaps
int badOverlaps (Readset *rs, Read *x)
{
  int i, nBad = 0 ;
  Array olap = findOverlaps (rs, x, 0) ;
  for (i = 0 ; i < arrayMax(olap) ; ++i) if (arrp(olap,i,Overlap)->isBad) ++nBad ;
  arrayDestroy (olap) ;
  return nBad ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2740
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x3450
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rdx
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
cmpb $0x0, 0xd(%rax,%rcx)
je 0x3443
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3445
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3411
movq -0x20(%rbp), %rdi
callq 0x9420
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server.c
// Function: printAccounts
void *printAccounts(void *emptyPtr)
{
	while (1)
	{
		signal(SIGALRM, alarmHandler);
		alarm(20);
		sem_wait(&semaphore);
		
		printf("ACCOUNT LIST\n");
		int i=0;
		printf("---------------------------------------\n");
		for (i=0;(i<numAcc && accountList[i]!=NULL);i++)
		{
			printf("%s\n", accountList[i]->accountName);
			printf("        %f\n", accountList[i]->balance);
			(accountList[i]->inUse==1) ? printf("        IN SESSION\n"):printf("        NOT IN SESSION\n");
		}
		
		printf("----------------------------------------\n");
		
		
	}
	pthread_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xe, %edi
leaq -0x38(%rip), %rsi       # 0x1330
callq 0x1130
movl $0x14, %edi
callq 0x10e0
leaq 0x6dc2(%rip), %rdi      # 0x8140
callq 0x1060
leaq 0x1c7a(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x10b0
movl $0x0, -0xc(%rbp)
leaq 0x1cb0(%rip), %rdi      # 0x304f
movb $0x0, %al
callq 0x10b0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl 0x6da8(%rip), %ecx      # 0x8160
movb %al, -0xd(%rbp)
jge 0x13d3
movslq -0xc(%rbp), %rcx
leaq 0x6da8(%rip), %rax      # 0x8170
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x13df
jmp 0x1463
movslq -0xc(%rbp), %rcx
leaq 0x6d86(%rip), %rax      # 0x8170
movq (%rax,%rcx,8), %rsi
leaq 0x1c1d(%rip), %rdi      # 0x3012
movb $0x0, %al
callq 0x10b0
movslq -0xc(%rbp), %rcx
leaq 0x6d69(%rip), %rax      # 0x8170
movq (%rax,%rcx,8), %rax
movss 0x64(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x1bfb(%rip), %rdi      # 0x3016
movb $0x1, %al
callq 0x10b0
movslq -0xc(%rbp), %rcx
leaq 0x6d43(%rip), %rax      # 0x8170
movq (%rax,%rcx,8), %rax
cmpl $0x1, 0x68(%rax)
jne 0x1447
leaq 0x1be4(%rip), %rdi      # 0x3022
movb $0x0, %al
callq 0x10b0
jmp 0x1455
leaq 0x1be8(%rip), %rdi      # 0x3036
movb $0x0, %al
callq 0x10b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13ad
leaq 0x1be4(%rip), %rdi      # 0x304e
movb $0x0, %al
callq 0x10b0
jmp 0x135c
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server.c
// Function: addAccount
int addAccount(char * name)
{
	pthread_mutex_lock(&addLock);
	
	if (numAcc>=maxAcc)
	{
		pthread_mutex_unlock(&addLock);
		
		return 1;	
	}
	else if (strlen(name)>maxName)
	{
		pthread_mutex_unlock(&addLock);
		
		return 2;
	}


	else
	{
		int i;
		for (i=0; i<numAcc && accountList[i]!=NULL; i++)
		{
			if (strcasecmp(name, accountList[i]->accountName)==0)
			{
				pthread_mutex_unlock(&addLock);
				return 3;
			}
				

		}
		account *newAccount=malloc(sizeof(account));
		strcpy(newAccount->accountName,name);
		newAccount->balance=0;
		newAccount->inUse=0;
		accountList[numAcc]=newAccount;
		numAcc++;
		
		pthread_mutex_unlock(&addLock);
		
		return 0;
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x6cd5(%rip), %rdi      # 0x8218
callq 0x1210
cmpl $0x14, 0x6c11(%rip)     # 0x8160
jl 0x1569
leaq 0x6cc0(%rip), %rdi      # 0x8218
callq 0x1150
movl $0x1, -0x4(%rbp)
jmp 0x166f
movq -0x10(%rbp), %rdi
callq 0x1090
cmpq $0x64, %rax
jbe 0x1590
leaq 0x6c99(%rip), %rdi      # 0x8218
callq 0x1150
movl $0x2, -0x4(%rbp)
jmp 0x166f
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl 0x6bbe(%rip), %ecx      # 0x8160
movb %al, -0x21(%rbp)
jge 0x15bd
movslq -0x14(%rbp), %rcx
leaq 0x6bbe(%rip), %rax      # 0x8170
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x15c6
jmp 0x1605
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x6b9b(%rip), %rax      # 0x8170
movq (%rax,%rcx,8), %rsi
callq 0x1040
cmpl $0x0, %eax
jne 0x15f8
leaq 0x6c2e(%rip), %rdi      # 0x8218
callq 0x1150
movl $0x3, -0x4(%rbp)
jmp 0x166f
jmp 0x15fa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1597
movl $0x6c, %edi
callq 0x1170
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1050
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x64(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x68(%rax)
movq -0x20(%rbp), %rdx
movslq 0x6b1e(%rip), %rcx      # 0x8160
leaq 0x6b27(%rip), %rax      # 0x8170
movq %rdx, (%rax,%rcx,8)
movl 0x6b0d(%rip), %eax      # 0x8160
addl $0x1, %eax
movl %eax, 0x6b04(%rip)      # 0x8160
leaq 0x6bb5(%rip), %rdi      # 0x8218
callq 0x1150
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server.c
// Function: startAccount
int startAccount(char * name)
{
	int i=0;
	
	for (i=0; i<maxAcc; i++)
	{
		if (!accountList[i])
		{
			return -1;
		}
		else if (strcasecmp(name, accountList[i]->accountName)==0)
		{
			pthread_mutex_lock(&startLock);
			
			if (accountList[i]->inUse==0)
			{
				accountList[i]->inUse=1;
				pthread_mutex_unlock(&startLock);
				return i;
			}
			else
			{
				pthread_mutex_unlock(&startLock);
				return -2;
			}

		}
	
	}
	
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x14, -0x14(%rbp)
jge 0x1751
movslq -0x14(%rbp), %rcx
leaq 0x6ac1(%rip), %rax      # 0x8170
cmpq $0x0, (%rax,%rcx,8)
jne 0x16c2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1758
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x6a9f(%rip), %rax      # 0x8170
movq (%rax,%rcx,8), %rsi
callq 0x1040
cmpl $0x0, %eax
jne 0x173f
leaq 0x6b5a(%rip), %rdi      # 0x8240
callq 0x1210
movslq -0x14(%rbp), %rcx
leaq 0x6a7a(%rip), %rax      # 0x8170
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x68(%rax)
jne 0x172a
movslq -0x14(%rbp), %rcx
leaq 0x6a65(%rip), %rax      # 0x8170
movq (%rax,%rcx,8), %rax
movl $0x1, 0x68(%rax)
leaq 0x6b23(%rip), %rdi      # 0x8240
callq 0x1150
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1758
leaq 0x6b0f(%rip), %rdi      # 0x8240
callq 0x1150
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1758
jmp 0x1741
jmp 0x1743
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x169a
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/califlower[P]Multithreaded_Bank/server.c
// Function: debitAccount
int debitAccount(int id, float amount)
{
	
	if ((accountList[id]->balance)-amount<0)
		return 1;
	else
	{
		accountList[id]->balance-=amount;
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x69e9(%rip), %rax      # 0x8170
movq (%rax,%rcx,8), %rax
movss 0x64(%rax), %xmm1
subss -0xc(%rbp), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x17a6
movl $0x1, -0x4(%rbp)
jmp 0x17cf
movss -0xc(%rbp), %xmm1
movslq -0x8(%rbp), %rcx
leaq 0x69ba(%rip), %rax      # 0x8170
movq (%rax,%rcx,8), %rax
movss 0x64(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x64(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server.c
// Function: listenConnection
void listenConnection(int sock)
{
	while (1)
	{
		/* accept incoming connections */
		connection_t *connection = (connection_t *)calloc(3, sizeof(connection_t));
		connection->sock = accept(sock, &connection->address, &connection->addr_len);
		
		if (connection->sock <= 0)
		{
			free(connection);
		}
		else
		{
			printf("Client Connection Accepted\n");
			
			pthread_create(&thread, 0, clientThread, (void *)connection);
			pthread_detach(thread);
			
			struct sockNode *temp=malloc(sizeof(struct sockNode));
			temp->sock=connection->sock;
			temp->next=head;
			head=temp;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x3, %edi
movl $0x18, %esi
callq 0x1120
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movq -0x10(%rbp), %rdx
addq $0x14, %rdx
callq 0x11d0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x25c2
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x262b
leaq 0xb31(%rip), %rdi       # 0x30fa
movb $0x0, %al
callq 0x10b0
movq -0x10(%rbp), %rcx
leaq 0x5c8d(%rip), %rdi      # 0x8268
xorl %eax, %eax
movl %eax, %esi
leaq -0xdd6(%rip), %rdx      # 0x1810
callq 0x11c0
movq 0x5c76(%rip), %rdi      # 0x8268
callq 0x1180
movl $0x10, %edi
callq 0x1170
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq 0x5bf8(%rip), %rcx      # 0x8210
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x5be5(%rip)      # 0x8210
jmp 0x257b
// File: /workspace/github_c_makefile_star2_O0/califlower[P]Multithreaded_Bank/server.c
// Function: initConnection
void initConnection()
{
	
	struct sockaddr_in address;
	
	pthread_mutex_init(&addLock, NULL);
	pthread_mutex_init(&startLock, NULL);
	
	sem_init(&semaphore, 0, 0);

	signal(SIGHUP, exitHandler);
	signal(SIGINT, exitHandler);
	
	/* create socket */
	sock = socket(AF_INET, SOCK_STREAM, 0);

	/* bind socket to port */
	address.sin_family = AF_INET;
	address.sin_addr.s_addr = INADDR_ANY;
	address.sin_port = htons(port);

	bind(sock, (struct sockaddr *)&address, sizeof(struct sockaddr_in));
	
	/* listen on port */
	listen(sock, 5);


	printf("Now Accepting Incoming Client Connections...\n");
	
	pthread_create(&lThread, NULL, printAccounts, NULL);
	pthread_detach(lThread);
	
	listenConnection(sock);
	

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5bd9(%rip), %rdi      # 0x8218
xorl %eax, %eax
movl %eax, %esi
callq 0x1200
leaq 0x5bf1(%rip), %rdi      # 0x8240
xorl %eax, %eax
movl %eax, %esi
callq 0x1200
leaq 0x5ae1(%rip), %rdi      # 0x8140
xorl %edx, %edx
movl %edx, %esi
callq 0x11a0
movl $0x1, %edi
leaq -0x11f4(%rip), %rsi     # 0x1480
callq 0x1130
movl $0x2, %edi
leaq -0x1205(%rip), %rsi     # 0x1480
callq 0x1130
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x1220
movl %eax, 0x5a87(%rip)      # 0x8128
movw $0x2, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl 0x5a78(%rip), %eax      # 0x812c
movzwl %ax, %edi
callq 0x10a0
movw %ax, -0xe(%rbp)
movl 0x5a62(%rip), %edi      # 0x8128
leaq -0x10(%rbp), %rsi
movl $0x10, %edx
callq 0x11b0
movl 0x5a4e(%rip), %edi      # 0x8128
movl $0x5, %esi
callq 0x1190
leaq 0xa2b(%rip), %rdi       # 0x3116
movb $0x0, %al
callq 0x10b0
leaq 0x5b77(%rip), %rdi      # 0x8270
xorl %eax, %eax
movl %eax, %ecx
leaq -0x13b4(%rip), %rdx     # 0x1350
movq %rcx, %rsi
callq 0x11c0
movq 0x5b5d(%rip), %rdi      # 0x8270
callq 0x1180
movl 0x5a0a(%rip), %edi      # 0x8128
callq 0x2570
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/inject.c
// Function: join
static void join(pid_t pid, char *type) {
  char *path;
  int fd;

  path = string("/proc/%u/ns/%s", pid, type);

  if ((fd = open(path, O_RDONLY)) >= 0) {
    if (syscall(__NR_setns, fd, 0) < 0 && strcmp(type, "user") == 0)
      errx(EXIT_FAILURE, "Failed to join user namespace");
    close(fd);
  } else if (errno != ENOENT) {
    errx(EXIT_FAILURE, "PID %u does not belong to you", pid);
  } else if (strcmp(type, "user") == 0) {
    errx(EXIT_FAILURE, "PID %u not found or user namespace unavailable", pid);
  }

  free(path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq 0x18cc(%rip), %rdi      # 0x4129
movb $0x0, %al
callq 0x3900
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x22a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jl 0x28c6
movl -0x1c(%rbp), %esi
movl $0x134, %edi            # imm = 0x134
xorl %edx, %edx
movb $0x0, %al
callq 0x21c0
cmpq $0x0, %rax
jge 0x28bc
movq -0x10(%rbp), %rdi
leaq 0x17a1(%rip), %rsi      # 0x4040
callq 0x2180
cmpl $0x0, %eax
jne 0x28bc
movl $0x1, %edi
leaq 0x1883(%rip), %rsi      # 0x4138
movb $0x0, %al
callq 0x2110
movl -0x1c(%rbp), %edi
callq 0x2150
jmp 0x2915
callq 0x2050
cmpl $0x2, (%rax)
je 0x28e6
movl -0x4(%rbp), %edx
movl $0x1, %edi
leaq 0x1877(%rip), %rsi      # 0x4156
movb $0x0, %al
callq 0x2110
movq -0x10(%rbp), %rdi
leaq 0x174f(%rip), %rsi      # 0x4040
callq 0x2180
cmpl $0x0, %eax
jne 0x2911
movl -0x4(%rbp), %edx
movl $0x1, %edi
leaq 0x186a(%rip), %rsi      # 0x4174
movb $0x0, %al
callq 0x2110
jmp 0x2913
jmp 0x2915
movq -0x18(%rbp), %rdi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/inject.c
// Function: getparent
static int getparent(pid_t child) {
  char *end, *line = NULL, *path, *start;
  pid_t parent = -1;
  size_t size;
  FILE *file;

  path = string("/proc/%u/stat", child);
  file = fopen(path, "r");
  free(path);

  if (file && getline(&line, &size, file) >= 0)
    /* "PID (NAME) S PPID ...", so PPID begins 4 chars after the last ')' */
    if ((start = strrchr(line, ')')) && strlen(start) >= 4) {
      parent = strtol(start + 4, &end, 10);
      if (end == start || *end != ' ')
        parent = -1;
    }

  if (file)
    fclose(file);
  if (line)
    free(line);

  return parent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq $0x0, -0x18(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %esi
leaq 0x184f(%rip), %rdi      # 0x41a3
movb $0x0, %al
callq 0x3900
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x1888(%rip), %rsi      # 0x41f2
callq 0x22b0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2040
cmpq $0x0, -0x40(%rbp)
je 0x29fb
movq -0x40(%rbp), %rdx
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x22d0
cmpq $0x0, %rax
jl 0x29fb
movq -0x18(%rbp), %rdi
movl $0x29, %esi
callq 0x2130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x29f9
movq -0x28(%rbp), %rdi
callq 0x20e0
cmpq $0x4, %rax
jb 0x29f9
movq -0x28(%rbp), %rdi
addq $0x4, %rdi
leaq -0x10(%rbp), %rsi
movl $0xa, %edx
callq 0x21d0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x29f0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x29f7
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
jmp 0x29f9
jmp 0x29fb
cmpq $0x0, -0x40(%rbp)
je 0x2a0b
movq -0x40(%rbp), %rdi
callq 0x20b0
cmpq $0x0, -0x18(%rbp)
je 0x2a1b
movq -0x18(%rbp), %rdi
callq 0x2040
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/map.c
// Function: denysetgroups
void denysetgroups(pid_t pid) {
  char *path, *text = "deny";
  int fd;

  path = string("/proc/%d/setgroups", pid);
  if ((fd = open(path, O_WRONLY)) < 0)
    errx(EXIT_FAILURE, "Failed to disable setgroups() in container");
  else if (write(fd, text, strlen(text)) != (ssize_t) strlen(text))
    errx(EXIT_FAILURE, "Failed to disable setgroups() in container");
  close(fd);
  free(path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
leaq 0x176f(%rip), %rax      # 0x41b1
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %esi
leaq 0x1766(%rip), %rdi      # 0x41b6
movb $0x0, %al
callq 0x3900
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x22a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x2a86
movl $0x1, %edi
leaq 0x174a(%rip), %rsi      # 0x41c9
movb $0x0, %al
callq 0x2110
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20e0
movl -0x34(%rbp), %edi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x2090
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x2ad8
movl $0x1, %edi
leaq 0x16f8(%rip), %rsi      # 0x41c9
movb $0x0, %al
callq 0x2110
jmp 0x2ada
movl -0x1c(%rbp), %edi
callq 0x2150
movq -0x10(%rbp), %rdi
callq 0x2040
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)