LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/wtable.c
// Function: wtable_del
bool wtable_del(struct wtable *t, const char *key)
{
	struct wentry *entry;

	if (is_wildcard(key, strlen(key))) {
		entry = wildcards_find_entry(t, key, true, NULL);

		if (!entry) {
			/* Key not found. */
			return false;
		}

		/* Mark the entry as free. */
		free(entry->key);
		entry->key = NULL;
		entry->key_len = 0;
		t->destructor(entry->value);
		entry->value = NULL;
		entry->in_use = false;

		t->ws_used_count--;

		/* Shrink if the table is less than 60% occupied. */
		if (t->ws_size > MIN_SIZE &&
		    (float)t->ws_used_count / t->ws_size < 0.6) {
			if (!resize_table(t, t->ws_used_count + 3))
				return false;
		}

		/* Invalidate the cache. We could be smart and walk it,
		 * removing only the positive hits, but it's also more
		 * expensive */
		cache_invalidate(t->wcache);

		return true;
	} else {
		return hash_del(t->finals, key);
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2100
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x4150
testb $0x1, %al
jne 0x43e8
jmp 0x4578
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3f10
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x4417
movb $0x0, 0x47(%rsp)
jmp 0x4590
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x2040
movq 0x28(%rsp), %rax
movq $0x0, (%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq 0x28(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x28(%rsp), %rax
movb $0x0, 0x18(%rax)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq 0x38(%rsp), %rax
cmpq $0xa, 0x10(%rax)
jbe 0x4563
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x18(%rsp)
testq %rax, %rax
movss %xmm0, 0x1c(%rsp)
js 0x44d3
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x8(%rsp)
testq %rax, %rax
movss %xmm0, 0xc(%rsp)
js 0x451d
movss 0x8(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x4(%rsp), %xmm0
movss 0xc(%rsp), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1ccf(%rip), %xmm0     # 0x6208
ucomisd %xmm1, %xmm0
jbe 0x4563
movq 0x38(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rsi
addq $0x3, %rsi
callq 0x4180
testb $0x1, %al
jne 0x4561
movb $0x0, 0x47(%rsp)
jmp 0x4590
jmp 0x4563
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x5090
movb $0x1, 0x47(%rsp)
jmp 0x4590
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x4e60
andb $0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/wtable.c
// Function: ws_matches_s
static bool ws_matches_s(const char *ws, size_t ws_len, const char *s,
                         size_t s_len, bool exact)
{
	if (ws == NULL || s == NULL)
		return false;

	if (exact || !is_wildcard(ws, ws_len)) {
		/* Exact match */
		if (ws_len != s_len)
			return false;
		return strcmp(ws, s) == 0;
	} else {
		/* Inexact match */
		return strlast(ws, s) >= ws_len - 1;
	}
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x45d1
cmpq $0x0, 0x18(%rsp)
jne 0x45d8
movb $0x0, 0x37(%rsp)
jmp 0x4648
testb $0x1, 0xf(%rsp)
jne 0x45f2
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4150
testb $0x1, %al
jne 0x4622
movq 0x20(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x4605
movb $0x0, 0x37(%rsp)
jmp 0x4648
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2200
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x4648
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4660
movl %eax, %eax
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
setae %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/wtable.c
// Function: strlast
static unsigned int strlast(const char *s1, const char *s2)
{
	unsigned int i = 0;

	while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2) {
		i++;
		s1++;
		s2++;
	}

	return i;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rsp)
je 0x46b1
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rsp)
je 0x46b1
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
movq -0x10(%rsp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x15(%rsp)
movb -0x15(%rsp), %al
testb $0x1, %al
jne 0x46bb
jmp 0x46e4
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x4672
movl -0x14(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/main.cpp
// Function: encode_BYTE(char*, char*)
void encode_BYTE(char* szInputName, char* szOutputName)
{
  file_map<BYTE> map_input(szInputName);
  file_writer<bit> file_comp_out;
  file_comp_out.create(szOutputName);

  arithmetic_encoder enc(&file_comp_out);
  adaptive_model<BYTE> mdl(&enc);

  DWORD adwHeader[2];
  
  adwHeader[0] = g_dwMagic;
  adwHeader[1] = map_input.get_size();

  file_comp_out.write_header((BYTE*)adwHeader, sizeof(adwHeader));
  
  for(;;)
  {
    BYTE b = map_input.read_next();
    if (map_input.eof()) 
    {
      mdl.encode_symbol(b);
      break;
    }
    mdl.encode_symbol(b);
  }
  BYTE b = map_input.read_next();
  mdl.encode_symbol(b);
  mdl.encode_eof();
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x2780
leaq 0x80(%rsp), %rdi
callq 0x2830
jmp 0x233f
movq 0xc8(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x2890
jmp 0x2356
leaq 0x58(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x28d0
jmp 0x236a
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x2910
jmp 0x237b
movl $0x68746542, 0x18(%rsp) # imm = 0x68746542
leaq 0xa0(%rsp), %rdi
callq 0x29f0
movl %eax, 0x10(%rsp)
jmp 0x2396
movl 0x10(%rsp), %eax
movl %eax, 0x1c(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movl $0x8, %edx
callq 0x2a20
jmp 0x23b7
jmp 0x23b9
leaq 0xa0(%rsp), %rdi
callq 0x2a50
movb %al, 0xf(%rsp)
jmp 0x23cc
movb 0xf(%rsp), %al
movb %al, 0x17(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x2a70
movb %al, 0xe(%rsp)
jmp 0x23e7
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x23f1
jmp 0x2444
movzbl 0x17(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x2aa0
jmp 0x2402
jmp 0x245a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x24cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x24be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2b60
jmp 0x24be
movzbl 0x17(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x2aa0
jmp 0x2455
jmp 0x23b9
leaq 0xa0(%rsp), %rdi
callq 0x2a50
movb %al, 0xd(%rsp)
jmp 0x246d
movb 0xd(%rsp), %al
movb %al, 0x16(%rsp)
movzbl 0x16(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x2aa0
jmp 0x2486
leaq 0x20(%rsp), %rdi
callq 0x2b40
jmp 0x2492
leaq 0x20(%rsp), %rdi
callq 0x2b60
leaq 0x80(%rsp), %rdi
callq 0x2b90
leaq 0xa0(%rsp), %rdi
callq 0x2c40
addq $0xd8, %rsp
retq
leaq 0x80(%rsp), %rdi
callq 0x2b90
leaq 0xa0(%rsp), %rdi
callq 0x2c40
movq 0x78(%rsp), %rdi
callq 0x2180
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/main.cpp
// Function: decode_BYTE(char*, char*)
void decode_BYTE(char* szInputName, char* szOutputName)
{
  file_map<bit> map_comp_input(szInputName);
  file_writer<BYTE> file_out;
  file_out.create(szOutputName);
  
  arithmetic_decoder dec(&map_comp_input);
  adaptive_model<BYTE> mdl(&dec);

  DWORD* dwBuffer = (DWORD*)map_comp_input.get_header();
  
  DWORD dwExpSize = dwBuffer[1];

  if (dwBuffer[0] == g_dwMagic)
  {
    for(DWORD i = 0; i < (dwExpSize / sizeof(BYTE)); ++i)
    {
      BYTE b = mdl.decode_symbol();
      file_out.send(b);
    }
  }
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xe0(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
movl $0x8, %edx
xorl %ecx, %ecx
callq 0x2cb0
leaq 0x90(%rsp), %rdi
callq 0x2d80
jmp 0x2532
movq 0xd8(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x2dd0
jmp 0x2549
leaq 0x68(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x2e10
jmp 0x255d
leaq 0x30(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2ea0
jmp 0x256e
leaq 0xa8(%rsp), %rdi
callq 0x2f60
movq %rax, 0x10(%rsp)
jmp 0x2582
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x68746542, (%rax)     # imm = 0x68746542
jne 0x264f
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl 0x24(%rsp), %ecx
shrq $0x0, %rcx
cmpq %rcx, %rax
jae 0x264d
leaq 0x30(%rsp), %rdi
callq 0x2f70
movb %al, 0xf(%rsp)
jmp 0x25d6
movb 0xf(%rsp), %al
movb %al, 0x1f(%rsp)
movzbl 0x1f(%rsp), %esi
leaq 0x90(%rsp), %rdi
callq 0x3040
jmp 0x25f2
jmp 0x25f4
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x25b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x2688
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x267b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2b60
jmp 0x267b
jmp 0x264f
leaq 0x30(%rsp), %rdi
callq 0x2b60
leaq 0x90(%rsp), %rdi
callq 0x30d0
leaq 0xa8(%rsp), %rdi
callq 0x3130
addq $0xe8, %rsp
retq
leaq 0x90(%rsp), %rdi
callq 0x30d0
leaq 0xa8(%rsp), %rdi
callq 0x3130
movq 0x88(%rsp), %rdi
callq 0x2180
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/main.cpp
// Function: main
int main(int argc, char** argv)
{
	if (argc < 4) {
		cout << "Usage: "<<argv[0]<<" <input path> <compression path> <decompression path>\n";
		return -1;
	}

	enc_szInputName = argv[1];
	enc_szOutputName = argv[2];
	dec_szInputName = argv[2];
	dec_szOutputName = argv[3];

	encode_BYTE(enc_szInputName, enc_szOutputName);
	decode_BYTE(dec_szInputName, dec_szOutputName);

	return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x4, 0x10(%rsp)
jge 0x2708
movq 0x5905(%rip), %rdi      # 0x7fd8
leaq 0x292a(%rip), %rsi      # 0x5004
callq 0x2100
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x2100
movq %rax, %rdi
leaq 0x2913(%rip), %rsi      # 0x500c
callq 0x2100
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x2776
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x59f0(%rip)      # 0x8108
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x59e8(%rip)      # 0x8110
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x59e0(%rip)      # 0x8118
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x59d8(%rip)      # 0x8120
movq 0x59b9(%rip), %rdi      # 0x8108
movq 0x59ba(%rip), %rsi      # 0x8110
callq 0x2300
movq 0x59b6(%rip), %rdi      # 0x8118
movq 0x59b7(%rip), %rsi      # 0x8120
callq 0x24f0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/u_file_writer.h
// Function: file_writer<bool>::file_writer()
file_writer() : m_fdFile(-1)
      {
        m_Buffer = (BYTE*)malloc(4 * 1024);
        if(m_Buffer)
        {
          m_dwCurrentByte = 0;
          m_dwBytesInBuffer = 4 * 1024;
          m_dwBitsInByte = 8;
          m_bitBuffer = 0;
        }
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x1000, %edi           # imm = 0x1000
callq 0x2130
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
je 0x2884
movq 0x8(%rsp), %rax
movl $0x0, 0x14(%rax)
movl $0x1000, 0x18(%rax)     # imm = 0x1000
movl $0x8, 0x1c(%rax)
movb $0x0, 0x10(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/adaptive_model.h
// Function: adaptive_model<unsigned char>::encode_symbol(unsigned char)
void adaptive_model<symbolT>::encode_symbol(symbolT symbol)
{
  if (m_encoder)
  {
    m_encoder->encode(cum_count(idx<symbolT>::from_symbol(symbol) - 1),
                      cum_count(idx<symbolT>::from_symbol(symbol)), //symbol_to_index(symbol)),
                      total_count());
    update(symbol);    
  }
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x28(%rax)
je 0x2b34
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
movzbl 0x1f(%rsp), %edi
callq 0x4040
movq 0x10(%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x4010
movl %eax, 0x8(%rsp)
movzbl 0x1f(%rsp), %edi
callq 0x4040
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x4010
movq 0x10(%rsp), %rdi
movl %eax, 0xc(%rsp)
callq 0x4060
movq (%rsp), %rdi
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
movl %eax, %ecx
callq 0x3e20
movq 0x10(%rsp), %rdi
movzbl 0x1f(%rsp), %esi
callq 0x4090
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/u_file_writer.h
// Function: file_writer<bool>::~file_writer()
~file_writer()
      {        
        DWORD nBytesWritten;
        
        nBytesWritten = write(m_fdFile, m_Buffer, m_dwCurrentByte);       
        ASSERT(nBytesWritten == m_dwCurrentByte);

        while(m_dwBitsInByte)
        {
          m_bitBuffer <<= 1;
          --m_dwBitsInByte;
        }

        nBytesWritten = write(m_fdFile, &m_bitBuffer, sizeof(BYTE));
        ASSERT(nBytesWritten == sizeof(BYTE));
    
        close(m_fdFile);
        free(m_Buffer);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %edi
movq 0x8(%rax), %rsi
movl 0x14(%rax), %eax
movl %eax, %edx
callq 0x2040
movq %rax, 0x10(%rsp)
jmp 0x2bba
movq 0x10(%rsp), %rax
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x2be7
movq 0x8(%rsp), %rax
movzbl 0x10(%rax), %ecx
shll %ecx
movb %cl, 0x10(%rax)
movl 0x1c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rax)
jmp 0x2bc3
movq 0x8(%rsp), %rsi
movl (%rsi), %edi
addq $0x10, %rsi
movl $0x1, %edx
callq 0x2040
movq %rax, (%rsp)
jmp 0x2c02
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movl %ecx, 0x1c(%rsp)
movl (%rax), %edi
callq 0x21b0
jmp 0x2c18
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2120
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x3190
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/u_file_map.h
// Function: file_map<unsigned char>::~file_map()
~file_map()
    {     
      if (m_bHand)
      {
        lseek(m_fdFile, 0, SEEK_SET);
        write(m_fdFile, m_FileMap, m_dwFileSize);
        //free(m_FileMap);
      }
      else
      {      
        munmap(m_FileMap, m_dwFileSize);
      }
      close(m_fdFile);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x25(%rax)
je 0x2c82
movq 0x8(%rsp), %rax
movl (%rax), %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x21a0
movq 0x8(%rsp), %rax
movl (%rax), %edi
movq 0x10(%rax), %rsi
movl 0x18(%rax), %eax
movl %eax, %edx
callq 0x2040
jmp 0x2c80
jmp 0x2c95
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x18(%rax), %eax
movl %eax, %esi
callq 0x2090
movq 0x8(%rsp), %rax
movl (%rax), %edi
callq 0x21b0
jmp 0x2ca3
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x3190
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/u_file_writer.h
// Function: file_writer<unsigned char>::file_writer()
file_writer() : m_fdFile(-1)
      {
        m_tBuffer = (T*)malloc(4 * 1024);
        if(m_tBuffer)
        {
          m_dwCurrentElem = 0;
          m_dwElemsInBuffer = (4 * 1024) / sizeof(T);
        }
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x1000, %edi           # imm = 0x1000
callq 0x2130
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
je 0x2dc9
movq 0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movl $0x1000, 0x14(%rax)     # imm = 0x1000
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/arithmetic_decoder.h
// Function: arithmetic_decoder::arithmetic_decoder(file_map<bool>*)
arithmetic_decoder(file_map<bit>* fm): top_value(0xFFFFFFFF), 
                                         l(0), 
                                         u(top_value), 
                                         tag(0)
  {  
    m_input = fm;
    for (size_t i = 0; i < (sizeof(tag) * 8); ++i)
    {
      tag <<= 1;
      tag += m_input->read_next();
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl $0x0, 0xc(%rax)
movl 0x8(%rax), %ecx
movl %ecx, 0x10(%rax)
movl $0x0, 0x14(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x10(%rsp)
cmpq $0x20, 0x10(%rsp)
jae 0x2e94
movq 0x8(%rsp), %rax
movl 0x14(%rax), %ecx
shll %ecx
movl %ecx, 0x14(%rax)
movq (%rax), %rdi
callq 0x32b0
movb %al, %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movzbl %cl, %ecx
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2e54
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/adaptive_model.h
// Function: adaptive_model<unsigned char>::decode_symbol()
symbolT adaptive_model<symbolT>::decode_symbol()
{
  symbolT symbol;
  if (m_decoder)
  {  
    DWORD target = m_decoder->decode_target(total_count());    
    DWORD index = search_index(target);

    m_decoder->decode(cum_count(index - 1),
                      cum_count(index),
                      total_count());

    symbol = idx<symbolT>::to_symbol(index);
    update(symbol);
  }

  return symbol;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x30(%rax)
je 0x3031
movq 0x18(%rsp), %rdi
movq 0x30(%rdi), %rax
movq %rax, (%rsp)
callq 0x4060
movq (%rsp), %rdi
movl %eax, %esi
callq 0x4370
movq 0x18(%rsp), %rdi
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %esi
callq 0x43c0
movq 0x18(%rsp), %rdi
movl %eax, 0x24(%rsp)
movq 0x30(%rdi), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4010
movq 0x18(%rsp), %rdi
movl %eax, 0x10(%rsp)
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x4010
movq 0x18(%rsp), %rdi
movl %eax, 0x14(%rsp)
callq 0x4060
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
movl %eax, %ecx
callq 0x4450
movl 0x24(%rsp), %edi
callq 0x4630
movq 0x18(%rsp), %rdi
movb %al, 0x2f(%rsp)
movzbl 0x2f(%rsp), %esi
callq 0x4090
movb 0x2f(%rsp), %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/u_file_writer.h
// Function: file_writer<unsigned char>::send(unsigned char)
inline bool send(T t)
      {
        m_tBuffer[m_dwCurrentElem] = t;
        if (++m_dwCurrentElem == m_dwElemsInBuffer)
        {
          DWORD nBytesWritten = write(m_fdFile, m_tBuffer, 
                                    m_dwElemsInBuffer * sizeof(T));
          
          m_dwCurrentElem = 0;
          ASSERT(nBytesWritten == (m_dwElemsInBuffer * sizeof(T)));
          if (nBytesWritten != (m_dwElemsInBuffer * sizeof(T))) 
            return false;
        }
        return true;
      }

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movb 0x17(%rsp), %sil
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %edx
movb %sil, (%rax,%rdx)
movl 0x10(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x10(%rcx)
cmpl 0x14(%rcx), %eax
jne 0x30ba
movq 0x8(%rsp), %rax
movl (%rax), %edi
movq 0x8(%rax), %rsi
movl 0x14(%rax), %eax
movl %eax, %edx
shlq $0x0, %rdx
callq 0x2040
movq 0x8(%rsp), %rcx
movl %eax, 0x10(%rsp)
movl $0x0, 0x10(%rcx)
movl 0x10(%rsp), %eax
movl 0x14(%rcx), %ecx
shlq $0x0, %rcx
cmpq %rcx, %rax
je 0x30b8
movb $0x0, 0x27(%rsp)
jmp 0x30bf
jmp 0x30ba
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/u_file_writer.h
// Function: file_writer<unsigned char>::~file_writer()
~file_writer()
      {
        DWORD nBytesWritten = write(m_fdFile, m_tBuffer, m_dwCurrentElem * sizeof(T));
        
        ASSERT(nBytesWritten == (m_dwCurrentElem * sizeof(T)));    
        close(m_fdFile);
        free(m_tBuffer);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %edi
movq 0x8(%rax), %rsi
movl 0x10(%rax), %eax
movl %eax, %edx
callq 0x2040
movq %rax, 0x10(%rsp)
jmp 0x30fa
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movl %ecx, 0x1c(%rsp)
movl (%rax), %edi
callq 0x21b0
jmp 0x3111
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2120
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x3190
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/u_file_map.h
// Function: file_map<bool>::create(char*, unsigned int)
bool create(char* szFileName, DWORD dwFileSize = 0)
    {
      m_fdFile = open(szFileName, O_RDWR);
      
      ASSERT(m_fdFile != -1);
      if (m_fdFile != -1)
      {
        if (dwFileSize == 0)
        {
          struct stat stFile;
        
          fstat(m_fdFile, &stFile);     
          m_dwFileSize = stFile.st_size;
        }
        else
        {
          m_dwFileSize = dwFileSize;
        }
        
              m_FileMap = (BYTE*)mmap(0, m_dwFileSize, PROT_READ | PROT_WRITE, 
                                      MAP_PRIVATE, m_fdFile, 0);
        m_DataMap = m_FileMap + m_dwSizeOfHeader;
          
        ASSERT(m_FileMap != MAP_FAILED);
        if (m_FileMap != MAP_FAILED)
        {
          m_iCurrentByte = 0;
          m_nBitsInCurrentByte = 0;
          m_CurrentByte = 0;
          return true;
        }               
      }
      return false;
    }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movl %edx, 0x9c(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, (%rsp)
movq 0xa0(%rsp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x20c0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
cmpl $-0x1, (%rax)
je 0x3290
cmpl $0x0, 0x9c(%rsp)
jne 0x3217
movq (%rsp), %rax
movl (%rax), %edi
leaq 0x8(%rsp), %rsi
callq 0x2160
movq (%rsp), %rax
movq 0x38(%rsp), %rcx
movl %ecx, 0x18(%rax)
jmp 0x3225
movq (%rsp), %rax
movl 0x9c(%rsp), %ecx
movl %ecx, 0x18(%rax)
movq (%rsp), %rax
movl 0x18(%rax), %ecx
movl %ecx, %esi
movl (%rax), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x2, %ecx
movq %r9, %rdi
callq 0x2190
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rcx
movl 0x28(%rax), %edx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq $-0x1, %rcx
cmpq %rcx, 0x10(%rax)
je 0x328e
movq (%rsp), %rax
movl $0x0, 0x1c(%rax)
movl $0x0, 0x20(%rax)
movb $0x0, 0x24(%rax)
movb $0x1, 0xb7(%rsp)
jmp 0x3298
jmp 0x3290
movb $0x0, 0xb7(%rsp)
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/u_file_map.h
// Function: file_map<bool>::read_next()
inline bit read_next()
    {
      if (m_nBitsInCurrentByte == 0) 
      {
        m_CurrentByte = m_DataMap[m_iCurrentByte++];
        m_nBitsInCurrentByte = 8;
      }
    
      bit retval = (MSB(m_CurrentByte) ? 1 : 0);
      m_CurrentByte <<= 1;
      --m_nBitsInCurrentByte;
    
      return (retval);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpl $0x0, 0x20(%rax)
jne 0x32e8
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movl 0x1c(%rax), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, 0x1c(%rax)
movl %edx, %edx
movb (%rcx,%rdx), %cl
movb %cl, 0x24(%rax)
movl $0x8, 0x20(%rax)
movq -0x18(%rsp), %rax
movzbl 0x24(%rax), %esi
sarl $0x7, %esi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, -0x9(%rsp)
movzbl 0x24(%rax), %ecx
shll %ecx
movb %cl, 0x24(%rax)
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movb -0x9(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/u_file_map.h
// Function: file_map<unsigned char>::create(char*, unsigned int)
bool create(char* szFileName, DWORD dwFileSize = 0)
    {
      m_fdFile = open(szFileName, O_RDWR);
      
      ASSERT(m_fdFile != -1);
      if (m_fdFile != -1)
      {
        struct stat stFile;     
        fstat(m_fdFile, &stFile);       
        
        if (dwFileSize == 0)
        {
          m_dwFileSize = stFile.st_size;          
          m_FileMap = (BYTE*)mmap(0, m_dwFileSize, PROT_READ | PROT_WRITE, 
                                  MAP_SHARED, m_fdFile, 0);                               
          m_bHand = false;
        }
        else
        {
          m_dwFileSize = dwFileSize;
          
          m_FileMap = (BYTE*)malloc(m_dwFileSize);
          
          ASSERT(m_FileMap != NULL);  
          if (m_FileMap == NULL)
            m_FileMap = (BYTE*)MAP_FAILED;
          
          /*m_FileMap = (BYTE*)mmap(0, m_dwFileSize, PROT_READ | PROT_WRITE, 
                                  MAP_ANON, -1, 0);*/
                                  
          read(m_fdFile, m_FileMap, stFile.st_size);
          m_bHand = true;
        }
        
        m_DataMap = (T*)(m_FileMap + m_dwSizeOfHeader);
          
        ASSERT(m_FileMap != MAP_FAILED);
        if (m_FileMap == MAP_FAILED)
        {
          //throw new bad_alloc();
        }
        else
        {
          m_iCurrentElem = 0;          
          return true;
        }        
      }
      return false;
    }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movl %edx, 0x9c(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, (%rsp)
movq 0xa0(%rsp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x20c0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
cmpl $-0x1, (%rax)
je 0x3462
movq (%rsp), %rax
movl (%rax), %edi
leaq 0x8(%rsp), %rsi
callq 0x2160
cmpl $0x0, 0x9c(%rsp)
jne 0x33d5
movq (%rsp), %rax
movq 0x38(%rsp), %rcx
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %ecx
movl %ecx, %esi
movl (%rax), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x1, %ecx
movq %r9, %rdi
callq 0x2190
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movb $0x0, 0x25(%rax)
jmp 0x342a
movq (%rsp), %rax
movl 0x9c(%rsp), %ecx
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %eax
movl %eax, %edi
callq 0x2130
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x10(%rax)
jne 0x340e
movq (%rsp), %rax
movq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movl (%rax), %edi
movq 0x10(%rax), %rsi
movq 0x38(%rsp), %rdx
callq 0x2140
movq (%rsp), %rax
movb $0x1, 0x25(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movl 0x20(%rax), %edx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq $-0x1, %rcx
cmpq %rcx, 0x10(%rax)
jne 0x344b
jmp 0x3460
movq (%rsp), %rax
movl $0x0, 0x1c(%rax)
movb $0x1, 0xb7(%rsp)
jmp 0x346a
jmp 0x3462
movb $0x0, 0xb7(%rsp)
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/adaptive_model.h
// Function: adaptive_model<unsigned char>::update(unsigned char)
void adaptive_model<symbolT>::update(symbolT new_symbol)
{
  for (DWORD j = idx<symbolT>::from_symbol(new_symbol); j < dwSize; ++j)
  {
    ++(m_cum_count[j]);
    
  } 

  if (m_cum_count[dwSize - 1] >= ((DWORD)UPPER_LIMIT >> 2) )
  {
    for (DWORD i = 1; i < dwSize; ++i)
    {
      m_cum_count[i] >>= 1;
      while (m_cum_count[i] <= m_cum_count[i - 1])
        ++m_cum_count[i];
    }
  }
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x1f(%rsp), %edi
callq 0x4040
movl %eax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0x40ee
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x3d90
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x40b8
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3d90
cmpl $0x3fffffff, (%rax)     # imm = 0x3FFFFFFF
jb 0x41b8
movl $0x1, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0x41b6
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x3d90
movl (%rax), %ecx
shrl %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x3d90
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x4(%rsp)
addq $0x10, %rdi
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3d90
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
ja 0x41a4
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x3d90
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4149
jmp 0x41a6
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x411d
jmp 0x41b8
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/u_file_writer.h
// Function: file_writer<bool>::send(bool)
inline bool send(bit b)
      {
        if (m_dwBitsInByte == 0)
        {
          m_Buffer[m_dwCurrentByte] = m_bitBuffer; 

          if (++m_dwCurrentByte == m_dwBytesInBuffer)
          {      
            DWORD nBytesWritten = write(m_fdFile, m_Buffer, m_dwBytesInBuffer);
          
            m_dwCurrentByte = 0;
            
            ASSERT(nBytesWritten == m_dwBytesInBuffer);
            if (nBytesWritten != m_dwBytesInBuffer)
              return false;
          }

          m_dwBitsInByte = 8;
          m_bitBuffer = 0;
        }

        --m_dwBitsInByte;
        m_bitBuffer <<= 1;

        if (b) m_bitBuffer += 0x1;  
        
        return true;
      }

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x1c(%rax)
jne 0x424b
movq 0x8(%rsp), %rcx
movb 0x10(%rcx), %sil
movq 0x8(%rcx), %rax
movl 0x14(%rcx), %edx
movb %sil, (%rax,%rdx)
movl 0x14(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x14(%rcx)
cmpl 0x18(%rcx), %eax
jne 0x423b
movq 0x8(%rsp), %rax
movl (%rax), %edi
movq 0x8(%rax), %rsi
movl 0x18(%rax), %eax
movl %eax, %edx
callq 0x2040
movq 0x8(%rsp), %rcx
movl %eax, 0x10(%rsp)
movl $0x0, 0x14(%rcx)
movl 0x10(%rsp), %eax
cmpl 0x18(%rcx), %eax
je 0x4239
movb $0x0, 0x27(%rsp)
jmp 0x427d
jmp 0x423b
movq 0x8(%rsp), %rax
movl $0x8, 0x1c(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rax)
movzbl 0x10(%rax), %ecx
shll %ecx
movb %cl, 0x10(%rax)
testb $0x1, 0x17(%rsp)
je 0x4278
movq 0x8(%rsp), %rax
movzbl 0x10(%rax), %ecx
addl $0x1, %ecx
movb %cl, 0x10(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/arithmetic_encoder.h
// Function: arithmetic_encoder::encode_eof()
inline void encode_eof()
  {
    for (size_t i = 0; i < sizeof(DWORD) * 8; ++i)
    {
      bit bit_to_send = ((MSB(l) == 0) ? 0 : 1);
      m_output->send(bit_to_send);
        
      l <<= 1;
      while (scale3 > 0)
      {
        m_output->send(!bit_to_send);
        --scale3;
      }
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0x20, 0x18(%rsp)
jae 0x4344
movq 0x8(%rsp), %rax
movl 0xc(%rax), %esi
shrl $0x1f, %esi
movl $0x1, %ecx
xorl %edx, %edx
cmpl $0x0, %esi
cmovel %edx, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, 0x17(%rsp)
movq (%rax), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x41c0
movq 0x8(%rsp), %rax
movl 0xc(%rax), %ecx
shll %ecx
movl %ecx, 0xc(%rax)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x432f
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movb 0x17(%rsp), %al
xorb $-0x1, %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x41c0
movq 0x8(%rsp), %rax
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x42fb
jmp 0x4331
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x42ac
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/arithmetic/adaptive_model.h
// Function: adaptive_model<unsigned char>::search_index(unsigned int)
inline DWORD search_index(DWORD target)
  {
    DWORD k;
    for (k = 1; k < dwSize; ++k)
      if ((m_cum_count[k - 1] <= target) && (target <m_cum_count[k]))
        break;
    return k;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x8(%rcx), %eax
jae 0x4446
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movl 0x18(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3d90
movl (%rax), %eax
cmpl 0x1c(%rsp), %eax
ja 0x4437
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x10, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x3d90
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jae 0x4437
jmp 0x4446
jmp 0x4439
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x43df
movl 0x18(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perf/dispatch.c
// Function: dispatch_accept
struct dispatch_state *
dispatch_accept(int s, struct wire_requestqueue * Q, struct perfstats * P)
{
	struct dispatch_state * D;

	/* Bake a cookie. */
	if ((D = malloc(sizeof(struct dispatch_state))) == NULL)
		goto err0;

	/* Initialize dispatcher. */
	D->readq = NULL;
	D->writeq = NULL;
	D->read_cookie = NULL;
	D->Q = Q;
	D->nrequests = 0;
	D->P = P;

	/* Accept a connection. */
	if ((D->accept_cookie = network_accept(s, callback_accept, D)) == NULL)
		goto err1;

	/* Success! */
	return (D);

err1:
	free(D);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x40, %edi
callq 0x22c0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x35a9
jmp 0x3627
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
movl -0xc(%rbp), %edi
movq -0x28(%rbp), %rdx
leaq 0x41(%rip), %rsi        # 0x3640
callq 0x80e0
movq -0x28(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0x3614
jmp 0x361e
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x362f
movq -0x28(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perf/dispatch.c
// Function: dispatch_done
void
dispatch_done(struct dispatch_state * D)
{

	/* Sanity-check. */
	assert(D->accept_cookie == NULL);
	assert(D->read_cookie == NULL);
	assert(D->nrequests == 0);

	/* Free the buffered reader and writer. */
	netbuf_read_free(D->readq);
	netbuf_write_free(D->writeq);

	/* Close the socket. */
	if (close(D->s))
		warnp("close");

	/* Free memory. */
	free(D);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x38e9
jmp 0x3908
leaq 0xeb38(%rip), %rdi      # 0x12428
leaq 0xeb4a(%rip), %rsi      # 0x12441
movl $0x12d, %edx            # imm = 0x12D
leaq 0xeb49(%rip), %rcx      # 0x1244c
callq 0x21d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x3915
jmp 0x3934
leaq 0xeb5c(%rip), %rdi      # 0x12478
leaq 0xeb1e(%rip), %rsi      # 0x12441
movl $0x12e, %edx            # imm = 0x12E
leaq 0xeb1d(%rip), %rcx      # 0x1244c
callq 0x21d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x3941
jmp 0x3960
leaq 0xeb47(%rip), %rdi      # 0x1248f
leaq 0xeaf2(%rip), %rsi      # 0x12441
movl $0x12f, %edx            # imm = 0x12F
leaq 0xeaf1(%rip), %rcx      # 0x1244c
callq 0x21d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x77e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7eb0
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x21f0
cmpl $0x0, %eax
je 0x39c3
jmp 0x398c
callq 0x20a0
cmpl $0x0, (%rax)
je 0x39b1
leaq 0xf53d(%rip), %rdi      # 0x12eda
movb $0x0, %al
callq 0xc460
callq 0x20a0
movl $0x0, (%rax)
jmp 0x39bf
leaq 0xf522(%rip), %rdi      # 0x12eda
movb $0x0, %al
callq 0xc6b0
jmp 0x39c1
jmp 0x39c3
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perf/dispatch.c
// Function: callback_gotresponse
static int
callback_gotresponse(void * cookie, uint8_t * buf, size_t buflen)
{
	struct forwardee * F = cookie;
	struct dispatch_state * D = F->D;
	struct wire_packet P;
	struct timeval t_end;
	uint64_t ID = F->ID;

	/* Get the completion time and compute request duration. */
	if (monoclock_get(&t_end))
		goto err1;

	/* Record the request duration. */
	if (perfstats_add(D->P, F->reqtype, timeval_diff(F->t_start, t_end)))
		goto err1;

	/* This request is no longer in flight. */
	D->nrequests--;

	/* Free the cookie. */
	mpool_forwardee_free(F);

	/* Did the request fail? */
	if (buf == NULL)
		goto failed;

	/* Send the response back to the client. */
	P.ID = ID;
	P.buf = buf;
	P.len = buflen;
	if (wire_writepacket(D->writeq, &P))
		goto err0;

	/* Success! */
	return (0);

failed:
	/*
	 * Stop reading requests -- if the target failed we won't be able to do
	 * anything useful with them anyway!  Once in-flight requests have been
	 * failed, dispatch_alive will return zero.
	 */
	if (D->read_cookie != NULL) {
		wire_readpacket_wait_cancel(D->read_cookie);
		D->read_cookie = NULL;
	}

	/* The failed request has been successfully handled. */
	return (0);

err1:
	mpool_forwardee_free(F);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xa3b0
cmpl $0x0, %eax
je 0x3c66
jmp 0x3d3e
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x28(%rbp), %rax
movl 0x20(%rax), %esi
movq -0x58(%rbp), %rax
movq -0x28(%rbp), %rcx
subq 0x10(%rcx), %rax
cvtsi2sd %rax, %xmm1
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
subq 0x18(%rcx), %rax
cvtsi2sd %rax, %xmm0
movsd 0xe781(%rip), %xmm2     # 0x12420
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x4220
cmpl $0x0, %eax
je 0x3cb6
jmp 0x3d3e
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rdi
callq 0x3e80
cmpq $0x0, -0x18(%rbp)
jne 0x3cd8
jmp 0x3d11
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x48(%rbp), %rsi
callq 0xee20
cmpl $0x0, %eax
je 0x3d08
jmp 0x3d47
movl $0x0, -0x4(%rbp)
jmp 0x3d4e
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3d35
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xde60
movq -0x30(%rbp), %rax
movq $0x0, 0x20(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3d4e
movq -0x28(%rbp), %rdi
callq 0x3e80
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perf/perfstats.c
// Function: perfstats_init
struct perfstats *
perfstats_init(struct logging_file * L, long w)
{
	struct perfstats * P;

	/* Bake a cookie. */
	if ((P = malloc(sizeof(struct perfstats))) == NULL)
		goto err0;
	P->L = L;
	P->secsperreport = w;
	if ((P->stats = reqstatslist_init(0)) == NULL)
		goto err1;

	/* Statistics prior to now have been reported. */
	if (timetrunc(&P->lastreport, P->secsperreport))
		goto err2;

	/* Start a timer. */
	if ((P->timer_cookie = events_timer_register_double(callback_timer,
	    P, 0.5)) == NULL)
		goto err2;

	/* Success! */
	return (P);

err2:
	reqstatslist_free(P->stats);
err1:
	free(P);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x28, %edi
callq 0x22c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4049
jmp 0x40dd
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x40f0
movq -0x20(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x4079
jmp 0x40d4
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4120
cmpl $0x0, %eax
je 0x4095
jmp 0x40c7
movq -0x20(%rbp), %rsi
leaq 0xe0(%rip), %rdi        # 0x4180
movsd 0xe508(%rip), %xmm0     # 0x125b0
callq 0x6ea0
movq -0x20(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0x40bd
jmp 0x40c7
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x40e5
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4200
movq -0x20(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perf/perfstats.c
// Function: timetrunc
static int
timetrunc(time_t * t, long w)
{

	/* Get the current time. */
	if (time(t) == (time_t)(-1))
		goto err0;

	/* Round down. */
	*t = (time_t)((long)(*t / w) * w);

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22b0
cmpq $-0x1, %rax
jne 0x4141
jmp 0x4166
movq -0x10(%rbp), %rax
movq (%rax), %rax
cqto
idivq -0x18(%rbp)
movq %rax, %rcx
imulq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x416d
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/Tarsnap[P]kivaloo/perf/perfstats.c
// Function: callback_timer
static int
callback_timer(void * cookie)
{
	struct perfstats * P = cookie;

	/* We are no longer waiting for this callback. */
	P->timer_cookie = NULL;

	/* Check if we need to flush statistics. */
	if (poke(P))
		goto err0;

	/* Schedule another callback. */
	if ((P->timer_cookie = events_timer_register_double(callback_timer,
	    P, 0.5)) == NULL)
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x4480
cmpl $0x0, %eax
je 0x41b0
jmp 0x41e1
movq -0x18(%rbp), %rsi
leaq -0x3b(%rip), %rdi       # 0x4180
movsd 0xe3ed(%rip), %xmm0     # 0x125b0
callq 0x6ea0
movq -0x18(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0x41d8
jmp 0x41e1
movl $0x0, -0x4(%rbp)
jmp 0x41e8
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/Tarsnap[P]kivaloo/perf/perfstats.c
// Function: poke
static int
poke(struct perfstats * P)
{
	time_t t_now;

	/* Get the current time. */
	if (timetrunc(&t_now, P->secsperreport))
		goto err0;

	/* Is it time to flush statistics? */
	if (t_now != P->lastreport) {
		if (flush(P))
			goto err0;
		P->lastreport = t_now;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0x4120
cmpl $0x0, %eax
je 0x44a4
jmp 0x44d7
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x44ce
movq -0x10(%rbp), %rdi
callq 0x45d0
cmpl $0x0, %eax
je 0x44c2
jmp 0x44d7
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x44de
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perf/perfstats.c
// Function: perfstats_done
int
perfstats_done(struct perfstats * P)
{
	int rc;

	/* Flush any unreported statistics. */
	rc = flush(P);

	/* Cancel the timer if we're waiting for a callback. */
	if (P->timer_cookie) {
		events_timer_cancel(P->timer_cookie);
		P->timer_cookie = NULL;
	}

	/* Free our state. */
	reqstatslist_free(P->stats);
	free(P);

	/* Return code from flush(). */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45d0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x45ac
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6f00
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4200
movq -0x8(%rbp), %rdi
callq 0x2040
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/innerlist.c
// Function: SH_InnerList__init
SH_InnerList*
SH_InnerList__init(int* err) {
	SH_InnerList* obj;

	__cascade(err, (SH_InnerList*)0);

	obj = (SH_InnerList*)malloc(sizeof(SH_InnerList));
	if ((SH_InnerList*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_InnerList*)0;
	}

	obj->count = 0;

	__clear(err);
	return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1198
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1198
movq $0x0, -0x8(%rbp)
jmp 0x11f3
movl $0x808, %edi            # imm = 0x808
callq 0x1080
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x11ca
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x11c0
movq -0x10(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x11f3
movq -0x18(%rbp), %rax
movq $0x0, 0x800(%rax)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x11eb
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/innerlist.c
// Function: SH_InnerList__add
void
SH_InnerList__add(SH_InnerList* obj, SH_Item* item, int* err) {
	__cascade(err,);
	if (obj->count >= SH_INNERLIST_CAPACITY) {
		__raise(err, SH_E_LIST_OVERFLOW);
		return;
	}
	obj->_list[obj->count++] = item;
	__clear(err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1304
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1304
jmp 0x1360
movq -0x8(%rbp), %rax
cmpq $0x100, 0x800(%rax) # imm = 0x100
jb 0x1329
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1327
movq -0x18(%rbp), %rax
movl $0x300001, (%rax)       # imm = 0x300001
jmp 0x1360
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movq 0x800(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x800(%rsi)
movq %rdx, (%rax,%rcx,8)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1360
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)