LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_resize
bool bitset_resize( bitset_t *bitset,  size_t newarraysize, bool padwithzeroes ) {
  size_t smallest = newarraysize < bitset->arraysize ? newarraysize : bitset->arraysize;
  if (bitset->capacity < newarraysize) {
    uint64_t *newarray;
    bitset->capacity = newarraysize * 2;
    if ((newarray = (uint64_t *) realloc(bitset->array, sizeof(uint64_t) * bitset->capacity)) == NULL) {
      free(bitset->array);
      return false;
    }
    bitset->array = newarray;
  }
  if (padwithzeroes && (newarraysize > smallest))
    memset(bitset->array + smallest,0,sizeof(uint64_t) * (newarraysize - smallest));
  bitset->arraysize = newarraysize;
  return true; // success!
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r12
cmpq %rsi, %r12
movq %rsi, %r15
cmovbq %r12, %r15
cmpq %rsi, 0x10(%rdi)
jae 0x2688
leaq (%r14,%r14), %rax
movq %rax, 0x10(%rbx)
movq (%rbx), %rdi
movq %r14, %rsi
shlq $0x4, %rsi
callq 0x10e0
testq %rax, %rax
je 0x26c0
movq %rax, (%rbx)
cmpq %r14, %r12
setb %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x26b1
leaq (,%r15,8), %rdi
addq (%rbx), %rdi
movq %r14, %rdx
subq %r15, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x1090
movq %r14, 0x8(%rbx)
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
callq 0x1040
xorl %eax, %eax
jmp 0x26b7
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_shift_right
void bitset_shift_right(bitset_t *bitset, size_t s) {
  size_t extra_words = s / 64;
  int inword_shift = s % 64;
  size_t as = bitset->arraysize;
  if(inword_shift == 0) {
    // could be done with a memmove
    for(size_t i = 0 ; i < as - extra_words; i++) {
      bitset->array[i] = bitset->array[i + extra_words];
    }
    bitset_resize(bitset,as - extra_words, false);

  } else {
    for(size_t i = 0 ; i + extra_words + 1 < as ; i++) {
      bitset->array[i] = (bitset->array[i + extra_words] >> inword_shift)
      | (bitset->array[i + extra_words + 1] << (64 - inword_shift));
    }
    bitset->array[as - extra_words - 1] = (bitset->array[as - 1] >> inword_shift);
    bitset_resize(bitset,as - extra_words , false);
  }
}

// Assembly:
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rsi, %r8
shrq $0x6, %r8
movl %eax, %ecx
movq 0x8(%rdi), %rsi
andl $0x3f, %ecx
je 0x273b
andl $0x3f, %eax
movl $0x40, %edx
subl %ecx, %edx
movq (%rdi), %r9
leaq 0x1(%r8), %r10
movq %r9, %r11
cmpq %rsi, %r10
jae 0x271f
movq (%r11,%r8,8), %rbx
movq 0x8(%r11,%r8,8), %r14
movl %eax, %ecx
shrq %cl, %rbx
movl %edx, %ecx
shlq %cl, %r14
orq %rbx, %r14
movq %r14, (%r11)
addq $0x8, %r11
incq %r10
jmp 0x26f8
movq -0x8(%r9,%rsi,8), %rdx
movl %eax, %ecx
shrq %cl, %rdx
subq %r8, %rsi
movq %rdx, -0x8(%r9,%rsi,8)
xorl %edx, %edx
popq %rbx
popq %r14
jmp 0x2645
subq %r8, %rsi
shlq $0x3, %r8
xorl %eax, %eax
cmpq %rax, %rsi
je 0x2731
movq (%rdi), %rcx
leaq (%rcx,%rax,8), %rdx
movq (%r8,%rdx), %rdx
movq %rdx, (%rcx,%rax,8)
incq %rax
jmp 0x2744
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_inplace_union
bool bitset_inplace_union(bitset_t * restrict b1, const bitset_t * restrict b2) {
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  for(size_t k = 0 ; k < minlength; ++k) {
    b1->array[k] |= b2->array[k];
  }
  if(b2->arraysize > b1->arraysize) {
     size_t oldsize = b1->arraysize;
     if(!bitset_resize( b1, b2->arraysize, false)) return false;
     memcpy(b1->array + oldsize, b2->array + oldsize, (b2->arraysize - oldsize) * sizeof(uint64_t));
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rbx
movq 0x8(%rsi), %rsi
cmpq %rsi, %rbx
movq %rsi, %rax
cmovbq %rbx, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x2a28
movq (%r14), %rdx
movq (%rdx,%rcx,8), %rdx
movq (%r15), %rdi
orq %rdx, (%rdi,%rcx,8)
incq %rcx
jmp 0x2a10
movb $0x1, %bpl
movq %rsi, %r12
subq %rbx, %r12
jbe 0x2a62
xorl %ebp, %ebp
movq %r15, %rdi
xorl %edx, %edx
callq 0x2645
testb %al, %al
je 0x2a62
shlq $0x3, %rbx
movq (%r15), %rdi
addq %rbx, %rdi
addq (%r14), %rbx
shlq $0x3, %r12
movq %rbx, %rsi
movq %r12, %rdx
callq 0x10c0
movb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_minimum
size_t bitset_minimum(const bitset_t *bitset) {
  for(size_t k = 0; k < bitset->arraysize; k++) {
    uint64_t w = bitset->array[k];
    if ( w != 0 ) {
      return __builtin_ctzll(w) + k * 64;
    }
  }
  return 0;
}

// Assembly:
movq 0x8(%rdi), %rdx
xorl %eax, %eax
xorl %ecx, %ecx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x2a98
movq (%rdi), %r8
movq (%r8,%rsi,8), %r8
testq %r8, %r8
jne 0x2a91
incq %rsi
addq $-0x40, %rcx
jmp 0x2a77
bsfq %r8, %rax
subq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_inplace_intersection
void bitset_inplace_intersection(bitset_t * restrict b1, const bitset_t * restrict b2) {
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  size_t k = 0;
  for( ; k < minlength; ++k) {
    b1->array[k] &= b2->array[k];
  }
  for(; k < b1->arraysize; ++k) {
    b1->array[k] = 0; // memset could, maybe, be a tiny bit faster
  }
}

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
cmpq %rcx, %rax
cmovbq %rax, %rcx
subq %rcx, %rax
subq %rcx, %rax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2e61
movq (%rsi), %r8
movq (%r8,%rdx,8), %r8
movq (%rdi), %r9
andq %r8, (%r9,%rdx,8)
incq %rdx
jmp 0x2e49
addq %rdx, %rax
subq $0x1, %rax
jb 0x2e77
movq (%rdi), %rdx
andq $0x0, (%rdx,%rcx,8)
incq %rcx
jmp 0x2e64
retq
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_intersection_count
size_t bitset_intersection_count(const bitset_t * restrict b1, const bitset_t * restrict b2) {
  size_t answer = 0;
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  for(size_t k = 0 ; k < minlength; ++k) {
    answer += __builtin_popcountll ( b1->array[k] & b2->array[k]);
  }
  return answer;
}

// Assembly:
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
cmpq %rcx, %rax
cmovbq %rax, %rcx
xorl %eax, %eax
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
movabsq $0x3333333333333333, %r8 # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f, %r9 # imm = 0xF0F0F0F0F0F0F0F
movabsq $0x101010101010101, %r10 # imm = 0x101010101010101
xorl %r11d, %r11d
cmpq %r11, %rcx
je 0x2f03
movq (%rdi), %rbx
movq (%rsi), %r14
movq (%r14,%r11,8), %r14
andq (%rbx,%r11,8), %r14
movq %r14, %rbx
shrq %rbx
andq %rdx, %rbx
subq %rbx, %r14
movq %r14, %rbx
andq %r8, %rbx
shrq $0x2, %r14
andq %r8, %r14
addq %rbx, %r14
movq %r14, %rbx
shrq $0x4, %rbx
addq %r14, %rbx
andq %r9, %rbx
imulq %r10, %rbx
shrq $0x38, %rbx
addq %rbx, %rax
incq %r11
jmp 0x2eb7
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_inplace_difference
void bitset_inplace_difference(bitset_t *restrict b1, const bitset_t * restrict b2) {
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  size_t k = 0;
  for( ; k < minlength; ++k) {
    b1->array[k] &= ~ (b2->array[k]);
  }
}

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rax
cmpq %rax, %rcx
cmovbq %rcx, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x2f33
movq (%rsi), %rdx
movq (%rdx,%rcx,8), %rdx
notq %rdx
movq (%rdi), %r8
andq %rdx, (%r8,%rcx,8)
incq %rcx
jmp 0x2f18
retq
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_difference_count
size_t  bitset_difference_count(const bitset_t *restrict b1, const bitset_t * restrict b2) {
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  size_t k = 0;
  size_t answer = 0;
  for( ; k < minlength; ++k) {
    answer += __builtin_popcountll (b1->array[k] & ~ (b2->array[k]));
  }
  for( ; k < b1->arraysize ; ++k) {
    answer += __builtin_popcountll (b1->array[k]);
  }
  return answer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
xorl %ebx, %ebx
movabsq $0x5555555555555555, %r8 # imm = 0x5555555555555555
movabsq $0x3333333333333333, %r9 # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f, %r10 # imm = 0xF0F0F0F0F0F0F0F
movabsq $0x101010101010101, %r11 # imm = 0x101010101010101
xorl %eax, %eax
cmpq %rbx, %rdx
je 0x3005
movq (%rdi), %r14
movq (%rsi), %r15
movq (%r15,%rbx,8), %r15
notq %r15
andq (%r14,%rbx,8), %r15
movq %r15, %r14
shrq %r14
andq %r8, %r14
subq %r14, %r15
movq %r15, %r14
andq %r9, %r14
shrq $0x2, %r15
andq %r9, %r15
addq %r14, %r15
movq %r15, %r14
shrq $0x4, %r14
addq %r15, %r14
andq %r10, %r14
imulq %r11, %r14
shrq $0x38, %r14
addq %r14, %rax
incq %rbx
jmp 0x2f74
movq (%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
movq %rsi, %rbx
shrq %rbx
andq %r8, %rbx
subq %rbx, %rsi
movq %rsi, %rbx
andq %r9, %rbx
shrq $0x2, %rsi
andq %r9, %rsi
addq %rbx, %rsi
movq %rsi, %rbx
shrq $0x4, %rbx
addq %rsi, %rbx
andq %r10, %rbx
imulq %r11, %rbx
shrq $0x38, %rbx
addq %rbx, %rax
incq %rdx
cmpq %rdx, %rcx
jne 0x2fc7
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_inplace_symmetric_difference
bool bitset_inplace_symmetric_difference(bitset_t *restrict b1, const bitset_t * restrict b2) {
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  size_t k = 0;
  for( ; k < minlength; ++k) {
    b1->array[k] ^= b2->array[k];
  }
  if(b2->arraysize > b1->arraysize) {
     size_t oldsize = b1->arraysize;
     if(!bitset_resize( b1, b2->arraysize, false)) return false;
     memcpy(b1->array + oldsize, b2->array + oldsize, (b2->arraysize - oldsize) * sizeof(uint64_t));
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rbx
movq 0x8(%rsi), %rsi
cmpq %rsi, %rbx
movq %rsi, %rax
cmovbq %rbx, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x304a
movq (%r14), %rdx
movq (%rdx,%rcx,8), %rdx
movq (%r15), %rdi
xorq %rdx, (%rdi,%rcx,8)
incq %rcx
jmp 0x3032
movb $0x1, %bpl
movq %rsi, %r12
subq %rbx, %r12
jbe 0x3084
xorl %ebp, %ebp
movq %r15, %rdi
xorl %edx, %edx
callq 0x2645
testb %al, %al
je 0x3084
shlq $0x3, %rbx
movq (%r15), %rdi
addq %rbx, %rdi
addq (%r14), %rbx
shlq $0x3, %r12
movq %rbx, %rsi
movq %r12, %rdx
callq 0x10c0
movb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_symmetric_difference_count
size_t  bitset_symmetric_difference_count(const bitset_t *restrict b1, const bitset_t * restrict b2) {
  size_t minlength = b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
  size_t k = 0;
  size_t answer = 0;
  for( ; k < minlength; ++k) {
    answer += __builtin_popcountll(b1->array[k] ^ b2->array[k]);
  }
  if(b2->arraysize > b1->arraysize) {
    for( ; k < b2->arraysize; ++k) {
      answer += __builtin_popcountll(b2->array[k]);
    }
  } else {
    for( ; k < b1->arraysize; ++k) {
      answer += __builtin_popcountll(b1->array[k]);
    }
  }
  return answer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rdi), %r11
movq 0x8(%rsi), %rbx
cmpq %rbx, %r11
movq %rbx, %rcx
cmovbq %r11, %rcx
xorl %r14d, %r14d
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
movabsq $0x3333333333333333, %r8 # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f, %r9 # imm = 0xF0F0F0F0F0F0F0F
movabsq $0x101010101010101, %r10 # imm = 0x101010101010101
xorl %eax, %eax
cmpq %r14, %rcx
je 0x3121
movq (%rdi), %r15
movq (%rsi), %r12
movq (%r12,%r14,8), %r12
xorq (%r15,%r14,8), %r12
movq %r12, %r15
shrq %r15
andq %rdx, %r15
subq %r15, %r12
movq %r12, %r15
andq %r8, %r15
shrq $0x2, %r12
andq %r8, %r12
addq %r15, %r12
movq %r12, %r15
shrq $0x4, %r15
addq %r12, %r15
andq %r9, %r15
imulq %r10, %r15
shrq $0x38, %r15
addq %r15, %rax
incq %r14
jmp 0x30d5
cmpq %rbx, %r11
jae 0x316f
cmpq %rcx, %rbx
je 0x31b4
movq (%rsi), %rdi
movq (%rdi,%rcx,8), %rdi
movq %rdi, %r11
shrq %r11
andq %rdx, %r11
subq %r11, %rdi
movq %rdi, %r11
andq %r8, %r11
shrq $0x2, %rdi
andq %r8, %rdi
addq %r11, %rdi
movq %rdi, %r11
shrq $0x4, %r11
addq %rdi, %r11
andq %r9, %r11
imulq %r10, %r11
shrq $0x38, %r11
addq %r11, %rax
incq %rcx
jmp 0x3126
cmpq %rcx, %r11
je 0x31b4
movq (%rdi), %rsi
movq (%rsi,%rcx,8), %rsi
movq %rsi, %rbx
shrq %rbx
andq %rdx, %rbx
subq %rbx, %rsi
movq %rsi, %rbx
andq %r8, %rbx
shrq $0x2, %rsi
andq %r8, %rsi
addq %rbx, %rsi
movq %rsi, %rbx
shrq $0x4, %rbx
addq %rsi, %rbx
andq %r9, %rbx
imulq %r10, %rbx
shrq $0x38, %rbx
addq %rbx, %rax
incq %rcx
jmp 0x316f
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/bitset.c
// Function: bitset_trim
bool bitset_trim(bitset_t * bitset) {
  size_t newsize = bitset->arraysize;
  while(newsize > 0) {
    if(bitset->array[newsize - 1] == 0)
        newsize -= 1;
    else
        break;
  }
  if(bitset->capacity == newsize) return true; // nothing to do
  bitset->capacity = newsize;
  bitset->arraysize = newsize;
  uint64_t *newarray;
  if ((newarray = (uint64_t *) realloc(bitset->array, sizeof(uint64_t) * bitset->capacity)) == NULL) {
      free(bitset->array);
      return false;
  }
  bitset->array = newarray;
  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq (,%rax,8), %rdx
negq %rdx
movq %rax, %rcx
movq %rdx, %rsi
subq $0x1, %rax
jb 0x31eb
movq (%rbx), %rdi
leaq 0x8(%rsi), %rdx
cmpq $0x0, (%rdi,%rax,8)
je 0x31d1
movb $0x1, %bpl
cmpq %rcx, 0x10(%rbx)
je 0x321b
movq %rcx, 0x10(%rbx)
movq %rcx, 0x8(%rbx)
movq (%rbx), %rdi
negq %rsi
callq 0x10e0
testq %rax, %rax
je 0x3211
movq %rax, (%rbx)
jmp 0x321b
movq (%rbx), %rdi
callq 0x1040
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/paeq128/aesni/encrypt.cpp
// Function: AES_Round(unsigned char*)
void AES_Round(unsigned char* state)  //SubBytes-ShiftRows-MixColumns
{
	unsigned char tmp[4][4];

	for (unsigned i = 0; i<4; ++i)
	{
		for (unsigned j = 0; j<4; ++j)
			tmp[j][i] = state[4 * i + j];//AES state conversion
	}
	for (unsigned i = 0; i<4; ++i)//Columnwise loop
	{
		state[4 * i] = mul[sbox[tmp[0][i]]][2] ^ mul[sbox[tmp[3][(i + 3) % 4]]][1] ^
			mul[sbox[tmp[2][(i + 2) % 4]]][1] ^ mul[sbox[tmp[1][(i + 1) % 4]]][3];
		state[4 * i + 1] = mul[sbox[tmp[1][(i + 1) % 4]]][2] ^ mul[sbox[tmp[0][i]]][1] ^
			mul[sbox[tmp[3][(i + 3) % 4]]][1] ^ mul[sbox[tmp[2][(i + 2) % 4]]][3];
		state[4 * i + 2] = mul[sbox[tmp[2][(i + 2) % 4]]][2] ^ mul[sbox[tmp[1][(i + 1) % 4]]][1] ^
			mul[sbox[tmp[0][i]]][1] ^ mul[sbox[tmp[3][(i + 3) % 4]]][3];
		state[4 * i + 3] = mul[sbox[tmp[3][(i + 3) % 4]]][2] ^ mul[sbox[tmp[2][(i + 2) % 4]]][1] ^
			mul[sbox[tmp[1][(i + 1) % 4]]][1] ^ mul[sbox[tmp[0][i]]][3];
	}

}

// Assembly:
pushq %rbx
leaq -0x10(%rsp), %rax
xorl %ecx, %ecx
movq %rdi, %rdx
cmpq $0x4, %rcx
je 0x11ee
xorl %esi, %esi
cmpq $0x4, %rsi
je 0x11e2
movb (%rdx,%rsi), %r8b
movb %r8b, (%rax,%rsi,4)
incq %rsi
jmp 0x11cf
incq %rcx
addq $0x4, %rdx
incq %rax
jmp 0x11c7
xorl %eax, %eax
leaq 0x1eb9(%rip), %rcx      # 0x30b0
movq 0x3dfa(%rip), %rdx      # 0x4ff8
cmpq $0x4, %rax
je 0x12c2
movzbl -0x10(%rsp,%rax), %esi
movzbl (%rsi,%rcx), %esi
shll $0x8, %esi
leal -0x1(%rax), %r8d
andl $0x3, %r8d
movzbl -0x4(%rsp,%r8), %r8d
movzbl (%r8,%rcx), %r8d
shll $0x8, %r8d
movb 0x1(%rdx,%r8), %r11b
xorb 0x2(%rdx,%rsi), %r11b
movq %rax, %r9
xorq $0x2, %r9
movzbl -0x8(%rsp,%r9), %r9d
movzbl (%r9,%rcx), %r10d
shll $0x8, %r10d
xorb 0x1(%rdx,%r10), %r11b
leaq 0x1(%rax), %r9
movl %r9d, %ebx
andl $0x3, %ebx
movzbl -0xc(%rsp,%rbx), %ebx
movzbl (%rbx,%rcx), %ebx
shll $0x8, %ebx
xorb 0x3(%rdx,%rbx), %r11b
movb %r11b, (%rdi,%rax,4)
movb 0x1(%rdx,%rsi), %r11b
xorb 0x2(%rdx,%rbx), %r11b
xorb 0x1(%rdx,%r8), %r11b
xorb 0x3(%rdx,%r10), %r11b
movb %r11b, 0x1(%rdi,%rax,4)
movb 0x1(%rdx,%rbx), %r11b
xorb 0x2(%rdx,%r10), %r11b
xorb 0x1(%rdx,%rsi), %r11b
xorb 0x3(%rdx,%r8), %r11b
movb %r11b, 0x2(%rdi,%rax,4)
movb 0x1(%rdx,%r10), %r10b
xorb 0x2(%rdx,%r8), %r10b
xorb 0x1(%rdx,%rbx), %r10b
xorb 0x3(%rdx,%rsi), %r10b
movb %r10b, 0x3(%rdi,%rax,4)
movq %r9, %rax
jmp 0x11fe
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/paeq128/aesni/encrypt.cpp
// Function: gmul_o(unsigned char, unsigned char)
unsigned char gmul_o(unsigned char a, unsigned char b) {
	unsigned char p = 0;
	unsigned char counter;
	unsigned char hi_bit_set;
	for (counter = 0; counter < 8; counter++) {
		if ((b & 1) == 1)
			p ^= a;
		hi_bit_set = (a & 0x80);
		a <<= 1;
		if (hi_bit_set == 0x80)
			a ^= 0x1b;
		b >>= 1;
	}
	return p;
}

// Assembly:
movb $0x8, %cl
xorl %eax, %eax
subb $0x1, %cl
jb 0x1648
movl %esi, %edx
andb $0x1, %dl
negb %dl
andb %dil, %dl
xorb %dl, %al
leal (%rdi,%rdi), %edx
movzbl %dl, %r8d
xorb $0x1b, %dl
testb %dil, %dil
movzbl %dl, %edi
cmovnsl %r8d, %edi
shrb %sil
jmp 0x161e
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/infoitem.cpp
// Function: InfoItem::InfoItem(smooth::String const&, smooth::String const&)
InfoItem::InfoItem(const String &iName, const String &iValue) : ListEntry(NIL)
{
	type	= classID;

	name	= iName;
	value	= iValue;

	UpdateText();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x8480
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8090
leaq 0x8(%rsp), %rdi
callq 0x8990
leaq 0xf60b(%rip), %rax      # 0x18178
movq %rax, (%rbx)
leaq 0x630(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x8480
leaq 0x648(%rbx), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x8480
movzwl 0x10949(%rip), %eax     # 0x194e2
movw %ax, 0x20(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x8550
movq %r13, %rdi
movq %r15, %rsi
callq 0x8550
movq %rbx, %rdi
callq 0x8c06
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x8bed
movq %rax, %r15
jmp 0x8bf5
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x8990
jmp 0x8bfd
movq %rax, %r15
movq %r13, %rdi
callq 0x8990
movq %r14, %rdi
callq 0x8990
movq %rbx, %rdi
callq 0x8970
movq %r15, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/section.cpp
// Function: Section::Save(smooth::XML::Node*, smooth::String const&)
Bool Section::Save(XML::Node *xmlSection, const String &templateName)
{
	for (Int i = 0; i < items.Length(); i++)
	{
		StringItem	*item = items.GetNth(i);

		/* If we have a template, save only
		 * entries with a translation.
		 */
		if (templateName == NIL || item->GetTranslation() != NIL)
		{
			XML::Node	*node = xmlSection->AddNode("entry", item->GetTranslation());

			node->SetAttribute("id", String::FromInt(item->GetID()));
			node->SetAttribute("string", item->GetOriginal());
		}
	}

	foreach (Section *section, sections)
	{
		XML::Node	*node = xmlSection->AddNode("section");

		node->SetAttribute("name", section->GetName());

		section->Save(node, templateName);
	}

	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
leaq 0x20(%rdi), %r15
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
leaq 0x30(%rsp), %r12
movq (%rsp), %rax
cmpl 0x28(%rax), %ebp
jge 0x97c5
movq %r15, %rdi
movl %ebp, %esi
callq 0xb65c
movq (%rax), %r14
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x84e0
testb %al, %al
jne 0x9728
leaq 0x650(%r14), %rdi
xorl %esi, %esi
callq 0x86f0
testb %al, %al
je 0x97be
movq %r13, %rdi
leaq 0x8c1d(%rip), %rsi      # 0x1234f
callq 0x8800
leaq 0x650(%r14), %rdx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x8570
movq %rax, %rbx
movq %r13, %rdi
callq 0x8990
movq %r13, %rdi
leaq 0x88d5(%rip), %rsi      # 0x12035
callq 0x8800
movslq 0x630(%r14), %rsi
movq %r12, %rdi
callq 0x8220
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x83c0
movq %r12, %rdi
callq 0x8990
movq %r13, %rdi
callq 0x8990
movq %r13, %rdi
leaq 0x889c(%rip), %rsi      # 0x12038
callq 0x8800
addq $0x638, %r14            # imm = 0x638
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x83c0
movq %r13, %rdi
callq 0x8990
incl %ebp
jmp 0x96e8
movq (%rsp), %rax
leaq 0xd0(%rax), %r12
xorl %r14d, %r14d
leaq 0x18(%rsp), %rbp
leaq 0x30(%rsp), %r13
leal -0x1(%r14), %eax
movq (%rsp), %rcx
movl 0xd8(%rcx), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0x987c
movq %r12, %rdi
movl %r14d, %esi
callq 0xaaf2
movq (%rax), %rbx
movq %rbp, %rdi
leaq 0x8832(%rip), %rsi      # 0x1203f
callq 0x8800
movq %r13, %rdi
xorl %esi, %esi
callq 0x8480
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x8570
movq %rax, %r15
movq %r13, %rdi
callq 0x8990
movq %rbp, %rdi
callq 0x8990
movq %rbp, %rdi
leaq 0x87e7(%rip), %rsi      # 0x12030
callq 0x8800
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x83c0
movq %rbp, %rdi
callq 0x8990
movq %rbx, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
callq 0x96bc
incl %r14d
jmp 0x97dd
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x98a6
jmp 0x9897
jmp 0x98a6
jmp 0x98a6
jmp 0x98a6
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8990
jmp 0x98a9
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8990
movq %rbx, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: int smooth::Signal1<void, smooth::GUI::ListEntry*>::Disconnect<Section, Section, void>(void (Section::*)(smooth::GUI::ListEntry*), Section*)
Int Disconnect(slotReturnTYPE (classTYPE::*proc)(SIGNALS_ARGUMENT_TYPES), oClassTYPE *inst)
			{
				if (slotsN == NIL) return Error();

				SIGNALS_SLOT_CLASS_CLASS_NAME<classTYPE, slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>	 slot(proc, inst);

				for (Int i = slotsN->Length() - 1; i >= 0; i--)
				{
					if ((*((SIGNALS_SLOT_BASE_CLASS_NAME<Void SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *) slotsN->GetNth(i))) == slot)
					{
						RemoveNthN(i);

						break;
					}
				}

				return Success();
			}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x9f30
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0xe6db(%rip), %rdi      # 0x185c0
movq %rsp, %r14
movq %rdi, (%r14)
movq %rsi, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq %rcx, 0x8(%r14)
movl 0x8(%rax), %ebp
testl %ebp, %ebp
jle 0x9f25
decl %ebp
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0xa13a
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x20(%rax)
testb %al, %al
je 0x9efa
movq %rbx, %rdi
movl %ebp, %esi
callq 0xa092
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: int smooth::Signal1<void, smooth::GUI::ListEntry*>::Connect<Section, Section, void>(void (Section::*)(smooth::GUI::ListEntry*), Section*)
Int Connect(slotReturnTYPE (classTYPE::*proc)(SIGNALS_ARGUMENT_TYPES), oClassTYPE *inst)
			{
				if (slotsN == NIL)
				{
					slotsN = new Array<Void *>();
					slotsN->EnableLocking();
				}

				slotsN->Add(new SIGNALS_SLOT_CLASS_CLASS_NAME<classTYPE, slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>(proc, inst));

				return Success();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x10(%rdi), %r13
testq %r13, %r13
jne 0x9f7b
movq %rdi, %r12
pushq $0x58
popq %rdi
callq 0x8530
movq %rax, %r13
movq %rax, %rdi
callq 0xb1ce
movq %r13, 0x10(%r12)
movq %r13, %rdi
callq 0x82b0
movq 0x10(%r12), %r13
pushq $0x20
popq %rdi
callq 0x8530
leaq 0xe636(%rip), %rcx      # 0x185c0
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r13, %rdi
callq 0xb4e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r13, %rdi
callq 0x80a0
movq %rbx, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: smooth::Signal1<void, smooth::GUI::ListEntry*>::Emit(smooth::GUI::ListEntry*) const
Void Emit(SIGNALS_ARGUMENT_PARAMETER_LIST) const
			{
				if (slotsN == NIL && slots0 == NIL) return;

				ProtectParent();

				for (Int i = 0; slotsN != NIL && i < slotsN->Length(); i++) ((SIGNALS_SLOT_BASE_CLASS_NAME<Void SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *) slotsN->GetNth(i))->Emit(SIGNALS_ARGUMENT_PARAMETERS);
				for (Int j = 0; slots0 != NIL && j < slots0->Length(); j++) ((SlotBase0<Void> *) slots0->GetNth(j))->Emit();

				UnprotectParent();
			}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rax
orq 0x10(%rdi), %rax
jne 0x9fe3
popq %rbx
popq %r14
popq %rbp
retq
movq %rsi, %r14
movq %rdi, %rbx
callq 0xb6ae
xorl %ebp, %ebp
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa015
cmpl 0x8(%rdi), %ebp
jge 0xa015
movl %ebp, %esi
callq 0xa13a
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
incl %ebp
jmp 0x9ff0
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xa039
cmpl 0x8(%rdi), %ebp
jge 0xa039
movl %ebp, %esi
callq 0xa13a
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
incl %ebp
jmp 0xa017
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb6c2
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: smooth::Signal1<void, smooth::GUI::ListEntry*>::RemoveNthN(int)
Void RemoveNthN(Int n)
			{
				if (slotsN == NIL)	   return;
				if (slotsN->Length() <= n) return;

				delete (SIGNALS_SLOT_BASE_CLASS_NAME<Void SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *) slotsN->GetNth(n);

				slotsN->RemoveNth(n);

				if (slotsN->Length() == 0)
				{
					delete slotsN;

					slotsN = NIL;
				}
			}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xa0de
movl %esi, %ebp
cmpl %esi, 0x8(%rdi)
jle 0xa0de
movl %ebp, %esi
callq 0xa13a
movq (%rax), %rdi
testq %rdi, %rdi
je 0xa0bd
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jne 0xa0de
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/signals/signal.h
// Function: smooth::Signal1<void, smooth::GUI::ListEntry*>::RemoveNth0(int)
Void RemoveNth0(Int n)
			{
				if (slots0 == NIL)	   return;
				if (slots0->Length() <= n) return;

				delete (SlotBase0<Void> *) slots0->GetNth(n);

				slots0->RemoveNth(n);

				if (slots0->Length() == 0)
				{
					delete slots0;

					slots0 = NIL;
				}
			}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xa132
movl %esi, %ebp
cmpl %esi, 0x8(%rdi)
jle 0xa132
movl %ebp, %esi
callq 0xa13a
movq (%rax), %rdi
testq %rdi, %rdi
je 0xa111
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x18(%rax)
movq 0x18(%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jne 0xa132
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<void*>::GetNth(int) const
const s &GetNth(Int n) const
			{
				ReadLock	 lock(*this);

				if (nOfEntries > n && n >= 0)
				{
					const s	&entry = entries[n]->value;

					lastAccessedEntry = n;

					return entry;
				}

				return nullValue;
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
callq 0xa1a0
leaq 0xf3af(%rip), %r15      # 0x19508
testl %ebx, %ebx
js 0xa174
cmpl %ebx, 0x8(%r14)
jle 0xa174
movq 0x48(%r14), %rax
movq (%rax), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %r15
movl %ebx, 0x14(%r14)
leaq 0x8(%rsp), %rdi
callq 0xa18c
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<StringItem*>::MoveNth(int, int)
Bool MoveNth(Int n, Int m)
			{
				WriteLock	 lock(*this);

				if (nOfEntries <= n || n < 0 ||
				    nOfEntries <= m || m < 0) return False;

				ArrayEntry
	*backupEntry = entries[n];

				if (m < n) memmove(entries + m + 1, entries + m, (n - m) * sizeof(ArrayEntry
 *));
				else	   memmove(entries + n, entries + n + 1, (m - n) * sizeof(ArrayEntry
 *));

				entries[m] = backupEntry;

				return IndexArray::MoveNth(n, m);
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
callq 0xa4a2
movl 0x8(%r14), %eax
cmpl %ebp, %eax
setle %cl
testl %ebp, %ebp
sets %dl
orb %cl, %dl
jne 0xa23b
cmpl %ebx, %eax
setle %al
testl %ebx, %ebx
sets %cl
orb %al, %cl
je 0xa23f
xorl %ebx, %ebx
jmp 0xa2a3
movq 0x48(%r14), %rax
movq (%rax), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %r15
movl %ebx, %edx
subl %ebp, %edx
jae 0xa273
movl %ebx, %r12d
leaq (%rax,%r12,8), %rsi
leaq (%rax,%r12,8), %rdi
addq $0x8, %rdi
movl %ebp, %eax
subl %ebx, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x80e0
jmp 0xa28a
leaq (%rax,%rcx,8), %rdi
leaq 0x8(%rdi), %rsi
movslq %edx, %rdx
shlq $0x3, %rdx
callq 0x80e0
movl %ebx, %r12d
movq 0x48(%r14), %rax
movq (%rax), %rax
movq %r15, (%rax,%r12,8)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x86d0
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xa48e
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa48e
movq %rbx, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<StringItem*>::RemoveNth(int)
Bool RemoveNth(Int n)
			{
				WriteLock	 lock(*this);

				if (nOfEntries <= n || n < 0) return False;

				if (nOfEntries == 1) return RemoveAll();

				delete entries[n];

				memmove(entries + n, entries + n + 1, (nOfEntries - n - 1) * sizeof(ArrayEntry
 *));

				return IndexArray::RemoveNth(n);
			}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
callq 0xa4a2
movl 0x8(%rbx), %eax
cmpl %ebp, %eax
setle %cl
testl %ebp, %ebp
sets %dl
orb %cl, %dl
je 0xa2fe
xorl %ebx, %ebx
jmp 0xa35f
cmpl $0x1, %eax
jne 0xa30e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
jmp 0xa35d
movq 0x48(%rbx), %rax
movq (%rax), %rax
movl %ebp, %r14d
movq (%rax,%r14,8), %rdi
pushq $0x8
popq %rsi
callq 0x80a0
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0xa332
movq (%rax), %rax
jmp 0xa334
xorl %eax, %eax
leaq (%rax,%r14,8), %rdi
leaq (%rax,%r14,8), %rsi
addq $0x8, %rsi
movl %ebp, %eax
notl %eax
addl 0x8(%rbx), %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x80e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8600
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xa48e
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa48e
movq %rbx, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<StringItem*>::RemoveAll()
Bool RemoveAll()
			{
				WriteLock	 lock(*this);

				if (nOfEntries == 0) return True;

				for (Int i = 0; i < nOfEntries; i++) delete entries[i];

				entries.Free();

				return IndexArray::RemoveAll();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
callq 0xa4a2
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0xa3e5
xorl %r15d, %r15d
pushq $0x8
popq %r14
cltq
cmpq %rax, %r15
jge 0xa3d0
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x80a0
incq %r15
movl 0x8(%rbx), %eax
jmp 0xa3ae
leaq 0x40(%rbx), %rdi
callq 0xa44e
movq %rbx, %rdi
callq 0x81a0
movl %eax, %ebx
jmp 0xa3e7
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0xa48e
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa48e
movq %rbx, %rdi
callq 0x8290
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/buffer/buffer.h
// Function: smooth::Buffer<smooth::ArrayEntry<StringItem*>*>::Free()
Bool Free()
			{
				/* Check if this is actually our memory.
				 */
				if (allocated == -1) return False;

				/* Nothing to free?
				 */
				if (memory == NIL) return True;

				delete memory;

				memory		= NIL;

				size		= 0;
				allocated	= 0;

				return True;
			}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x14(%rdi), %ebp
cmpl $-0x1, %ebp
je 0xa483
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0xa483
addq $0x8, %rbx
movq %r14, %rdi
callq 0x85c0
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x80a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
cmpl $-0x1, %ebp
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<StringItem*>::GetNthReference(int)
s &GetNthReference(Int n)
			{
				ReadLock	 lock(*this);

				if (nOfEntries > n && n >= 0)
				{
					s	&entry = entries[n]->value;

					lastAccessedEntry = n;

					return entry;
				}

				return nullValue;
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
callq 0xa1a0
leaq 0xeaa3(%rip), %r15      # 0x19510
testl %ebx, %ebx
js 0xaa88
cmpl %ebx, 0x8(%r14)
jle 0xaa88
movq 0x48(%r14), %rax
movq (%rax), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %r15
movl %ebx, 0x14(%r14)
leaq 0x8(%rsp), %rdi
callq 0xa18c
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<smooth::GUI::ListEntry*>::Add(smooth::GUI::ListEntry* const&, int)
Bool Add(const s &value, Int index)
			{
				WriteLock	 lock(*this);
				Int		 nOfEntries = this->nOfEntries;

				if (!IndexArray::InsertAtPos(nOfEntries, index)) return False;

				if (entries.Size() == nOfEntries) entries.Resize(8 > nOfEntries * 1.25 ? 8 : nOfEntries * 1.25);

				entries[nOfEntries] = new ArrayEntry
(value);

				return True;
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, (%rsp)
callq 0xa4a2
movl 0x8(%rbx), %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x80b0
movl %eax, %ebp
testb %al, %al
je 0xac5b
cmpl %r15d, 0x50(%rbx)
jne 0xac3f
leaq 0x40(%rbx), %rdi
cvtsi2sd %r15d, %xmm0
mulsd 0x73f6(%rip), %xmm0     # 0x12020
movsd 0x73f6(%rip), %xmm1     # 0x12028
maxsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
callq 0xac84
pushq $0x8
popq %rdi
callq 0x8530
movslq %r15d, %rcx
movq (%r14), %rdx
movq %rdx, (%rax)
movq 0x48(%rbx), %rdx
movq (%rdx), %rdx
movq %rax, (%rdx,%rcx,8)
movq %rsp, %rdi
callq 0xa48e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa48e
movq %rbx, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/buffer/buffer.h
// Function: smooth::Buffer<smooth::ArrayEntry<smooth::GUI::ListEntry*>*>::Resize(int)
Bool Resize(Int nSize)
			{
				/* Check if this is actually our memory.
				 */
				if (allocated == -1) return False;

				/* Let's see if we really need to reallocate.
				 */
				if (nSize > allocated)
				{
					if (memory != NIL) memory->Resize(nSize * sizeof(t));
					else		   memory = new Memory(nSize * sizeof(t));

					size		= nSize;
					allocated	= nSize;
				}
				else
				{
					size		= nSize;
				}

				return True;
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x14(%rdi), %ebp
cmpl $-0x1, %ebp
je 0xacdf
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, %ebp
jge 0xacb3
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xacb9
leal (,%rbx,8), %esi
callq 0x81b0
jmp 0xacd7
movl %ebx, 0x10(%r14)
jmp 0xacdf
pushq $0x8
popq %rdi
callq 0x8530
movq %rax, %r15
leal (,%rbx,8), %esi
movq %rax, %rdi
callq 0x8590
movq %r15, 0x8(%r14)
movl %ebx, 0x10(%r14)
movl %ebx, 0x14(%r14)
cmpl $-0x1, %ebp
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x80a0
movq %rbx, %rdi
callq 0x8290
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/stringitem.cpp
// Function: StringItem::StringItem(int, smooth::String const&, smooth::String const&)
StringItem::StringItem(Int iID, const String &iOriginal, const String &iTranslation) : ListEntry(NIL)
{
	type		= classID;

	id		= iID;

	original	= iOriginal;
	translation	= iTranslation;

	UpdateText();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x8480
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8090
movq %rsp, %rdi
callq 0x8990
leaq 0xcfd8(%rip), %rax      # 0x186f0
movq %rax, (%rbx)
leaq 0x638(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x8480
leaq 0x650(%rbx), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x8480
movzwl 0xddec(%rip), %eax      # 0x19530
movw %ax, 0x20(%rbx)
movl %ebp, 0x630(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x8550
movq %r13, %rdi
movq %r15, %rsi
callq 0x8550
movq %rbx, %rdi
callq 0xb7b6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0xb79d
movq %rax, %r15
jmp 0xb7a5
movq %rax, %r15
movq %rsp, %rdi
callq 0x8990
jmp 0xb7ad
movq %rax, %r15
movq %r13, %rdi
callq 0x8990
movq %r14, %rdi
callq 0x8990
movq %rbx, %rdi
callq 0x8970
movq %r15, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/../../include/smooth/main.h
// Function: main
int main(int argc, char **argv)
{
	ArgumentsParser	 args(argc, argv);

	GUI::Application::SetCommand(args.GetCommand());
	GUI::Application::SetArguments(args.GetArguments());

	GUI::Application::GetStartupDirectory();
	GUI::Application::GetApplicationDirectory();

	Int	 retValue = -1;

	if (Init())
	{
		if (System::System::GetAPIVersion() != (String) SMOOTH_APIVERSION)
		{
			Free();

			return -1;
		}

		retValue = Main();

		Free();
	}

	return retValue;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x838, %rsp            # imm = 0x838
movq %rsi, %rdx
movl %edi, %esi
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x88e0
movq %rbx, %rdi
callq 0x10d62
leaq 0x68(%rsp), %rdi
callq 0x8670
leaq 0x38(%rsp), %rdi
callq 0x88c0
leaq 0x38(%rsp), %rdi
callq 0x8990
leaq 0x20(%rsp), %rdi
callq 0x8320
leaq 0x20(%rsp), %rdi
callq 0x8990
callq 0x83e0
pushq $-0x1
popq %rbx
testb %al, %al
je 0xb99d
leaq 0xc0(%rsp), %rdi
callq 0x8360
leaq 0x69c4(%rip), %rsi      # 0x122e1
leaq 0x8(%rsp), %rdi
callq 0x8800
leaq 0xc0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8700
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x8990
leaq 0xc0(%rsp), %rdi
callq 0x8990
testb %bpl, %bpl
je 0xb95e
callq 0x85d0
jmp 0xb99d
movq 0xd61b(%rip), %rdi      # 0x18f80
xorl %esi, %esi
callq 0x114e6
leaq 0xc0(%rsp), %rdi
movq %rax, %rsi
callq 0xba00
leaq 0xc0(%rsp), %rdi
callq 0x8790
movl %eax, %ebx
leaq 0xc0(%rsp), %rdi
callq 0xfa64
callq 0x85d0
leaq 0x50(%rsp), %rdi
callq 0x86e0
movl %ebx, %eax
addq $0x838, %rsp            # imm = 0x838
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0xfa64
jmp 0xb9ed
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8990
jmp 0xb9d7
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x8990
jmp 0xb9ed
jmp 0xb9ea
jmp 0xb9ea
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x86e0
movq %rbx, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::FilterEntries()
Void Translator::FilterEntries()
{
	/* Clean up if filter text is empty.
	 */
	if (edit_filter->GetText() == NIL)
	{
		ClearFilter();

		return;
	}

	/* Update entries and exchange list widgets.
	 */
	Surface	*surface = wnd->GetDrawSurface();

	surface->StartPaint(Rect(list_entries->GetRealPosition(), list_entries->GetRealSize()));

	Int	 scrollbarPos = -1;

	if (list_filtered->IsVisible()) scrollbarPos = ((Scrollbar *) list_filtered->GetNthObject(0))->GetValue();

	list_entries->Hide();

	ClearFilter(list_filtered);

	dataSection->Filter(edit_filter->GetText().ToLower(), list_filtered);

	((Scrollbar *) list_filtered->GetNthObject(0))->SetValue(scrollbarPos);

	list_filtered->Show();

	surface->EndPaint();

	/* Activate clear button.
	 */
	button_clear->Activate();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x5f0(%rdi), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x84e0
testb %al, %al
je 0xd5b7
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd6fc
movq 0x5b8(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %r14
movq 0x600(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %r15
movq %rax, %r12
shrq $0x20, %r12
movq 0x600(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
leal (%rax,%r15), %ecx
shrq $0x20, %rax
leaq 0x8(%rsp), %rsi
movl %r15d, (%rsi)
movl %r12d, 0x4(%rsi)
movl %ecx, 0x8(%rsi)
addl %r12d, %eax
movl %eax, 0xc(%rsi)
movq %r14, %rdi
callq 0x84f0
movq 0x608(%rbx), %rdi
movq (%rdi), %rax
callq *0x90(%rax)
testb %al, %al
je 0xd63d
movq 0x608(%rbx), %rdi
xorl %esi, %esi
callq 0x114b2
movq 0x5d0(%rax), %rax
movl (%rax), %ebp
jmp 0xd640
pushq $-0x1
popq %rbp
movq 0x600(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq 0x608(%rbx), %rsi
movq %rbx, %rdi
callq 0xfea4
movq 0x768(%rbx), %r15
movq 0x5f0(%rbx), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x8380
movq 0x608(%rbx), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x9b76
leaq 0x8(%rsp), %rdi
callq 0x8990
movq 0x608(%rbx), %rdi
xorl %esi, %esi
callq 0x114b2
movq %rax, %rdi
movl %ebp, %esi
callq 0x8710
movq 0x608(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq %r14, %rdi
callq 0x8910
movq 0x5f8(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8990
movq %rbx, %rdi
callq 0x8290
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::ClearFilter()
Void Translator::ClearFilter()
{
	/* Clear filter box.
	 */
	edit_filter->SetText(NIL);
	button_clear->Deactivate();

	/* Clean up entries and exchange list widgets.
	 */
	Surface	*surface = wnd->GetDrawSurface();

	surface->StartPaint(Rect(list_filtered->GetRealPosition(), list_filtered->GetRealSize()));

	list_filtered->Hide();

	ClearFilter(list_filtered);

	list_entries->Show();

	surface->EndPaint();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x5f0(%rdi), %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x8480
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8990
movq 0x5f8(%rbx), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq 0x5b8(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %r14
movq 0x608(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, %r12
movq %rax, %r13
shrq $0x20, %r13
movq 0x608(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
leal (%rax,%r12), %ecx
shrq $0x20, %rax
movl %r12d, (%r15)
movl %r13d, 0x4(%r15)
movl %ecx, 0x8(%r15)
addl %r13d, %eax
movl %eax, 0xc(%r15)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x84f0
movq 0x608(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq 0x608(%rbx), %rsi
movq %rbx, %rdi
callq 0xfea4
movq 0x600(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq %r14, %rdi
callq 0x8910
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8990
movq %rbx, %rdi
callq 0x8290
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/translator/translator.cpp
// Function: Translator::OnChangeEditLayerSize(smooth::GUI::Size const&)
Void Translator::OnChangeEditLayerSize(const Size &size)
{
	edit_original->SetSize(Size(size.cx - edit_original->GetX() - 7, (size.cy - 50) / 2));

	text_translated->SetY(edit_original->GetY() + edit_original->GetHeight() + 11);
	edit_translated->SetY(text_translated->GetY() - 3);

	edit_translated->SetSize(Size(edit_original->GetWidth(), edit_original->GetHeight() + (size.cy & 1)));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x658(%rdi), %rdi
movl $0xa8, %ebx
leaq (%rdi,%rbx), %rsi
movl (%r14), %ecx
subl 0xa8(%rdi), %ecx
movl 0x4(%r14), %eax
addl $-0x7, %ecx
addl $-0x32, %eax
pushq $0x2
popq %r8
cltd
idivl %r8d
movq %rsp, %r12
movl %ecx, (%r12)
movl %eax, 0x4(%r12)
movq (%rdi), %rax
movq %r12, %rdx
callq *0x150(%rax)
movq 0x658(%r15), %rax
movq 0x660(%r15), %rdi
movl 0xac(%rax), %ecx
movl 0xb4(%rax), %eax
leal (%rcx,%rax), %esi
addl $0xb, %esi
callq 0x112d6
movq 0x660(%r15), %rax
movq 0x668(%r15), %rdi
movl 0xac(%rax), %esi
addl $-0x3, %esi
callq 0x112d6
movq 0x668(%r15), %rdi
movq 0x658(%r15), %rax
movl 0xb0(%rax), %ecx
movl 0x4(%r14), %edx
andl $0x1, %edx
addl 0xb4(%rax), %edx
movl %ecx, (%r12)
movl %edx, 0x4(%r12)
addq %rdi, %rbx
movq (%rdi), %rax
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x150(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq