LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r13
cmpq %rsi, %r13
movq %rsi, %r12
cmovbq %r13, %r12
cmpq %rsi, 0x10(%rdi)
jae 0x2a02
leaq (%rbx,%rbx), %rax
movq %rax, 0x10(%r14)
movq (%r14), %rdi
movq %rbx, %rsi
shlq $0x4, %rsi
callq 0x10d0
movq %rax, %r15
testq %rax, %rax
je 0x29f5
movq %r15, (%r14)
jmp 0x29fd
movq (%r14), %rdi
callq 0x1040
testq %r15, %r15
je 0x2a40
cmpq %rbx, %r13
setb %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x2a2b
leaq (,%r12,8), %rdi
addq (%r14), %rdi
movq %rbx, %rdx
subq %r12, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x1090
movq %rbx, 0x8(%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x2a31
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rax
movq %rsi, %r9
shrq $0x6, %r9
movl %eax, %ecx
movq 0x8(%rdi), %rsi
andl $0x3f, %ecx
je 0x2ac8
leaq 0x1(%r9), %rdx
cmpq %rsi, %rdx
jae 0x2ab1
movq (%rdi), %r10
movl %eax, %edx
andl $0x3f, %edx
movl $0x40, %r8d
subl %ecx, %r8d
movq %r9, %r11
notq %r11
addq %rsi, %r11
leaq (%r10,%r9,8), %rbx
addq $0x8, %rbx
xorl %r14d, %r14d
movq -0x8(%rbx,%r14,8), %r15
movq (%rbx,%r14,8), %r12
movl %edx, %ecx
shrq %cl, %r15
movl %r8d, %ecx
shlq %cl, %r12
orq %r15, %r12
movq %r12, (%r10,%r14,8)
incq %r14
cmpq %r14, %r11
jne 0x2a8e
movq (%rdi), %rdx
movq -0x8(%rdx,%rsi,8), %r8
movl %eax, %ecx
shrq %cl, %r8
subq %r9, %rsi
movq %r8, -0x8(%rdx,%rsi,8)
jmp 0x2ae3
subq %r9, %rsi
je 0x2ae3
movq (%rdi), %rax
movq %rsi, %rcx
movq (%rax,%r9,8), %rdx
movq %rdx, (%rax)
addq $0x8, %rax
decq %rcx
jne 0x2ad3
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x29aa
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
je 0x2dfe
movq (%r14), %rcx
movq (%r15), %rdx
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
orq %r8, (%rdx,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x2dee
movb $0x1, %bpl
movq %rsi, %r12
subq %rbx, %r12
jbe 0x2e38
xorl %ebp, %ebp
movq %r15, %rdi
xorl %edx, %edx
callq 0x29aa
testb %al, %al
je 0x2e38
shlq $0x3, %rbx
movq (%r15), %rdi
addq %rbx, %rdi
addq (%r14), %rbx
shlq $0x3, %r12
movq %rbx, %rsi
movq %r12, %rdx
callq 0x10b0
movb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rcx
testq %rcx, %rcx
je 0x2e76
movq (%rdi), %rdx
xorl %esi, %esi
xorl %edi, %edi
movq %rax, %r8
movq (%rdx,%rdi,8), %r9
bsfq %r9, %rax
addq %rsi, %rax
testq %r9, %r9
cmoveq %r8, %rax
jne 0x2e78
incq %rdi
addq $0x40, %rsi
cmpq %rdi, %rcx
jne 0x2e53
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rdx
movq 0x8(%rsi), %rcx
cmpq %rcx, %rdx
cmovbq %rdx, %rcx
testq %rcx, %rcx
je 0x3318
movq (%rsi), %rsi
movq (%rdi), %r8
xorl %eax, %eax
movq (%rsi,%rax,8), %r9
andq %r9, (%r8,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x3306
jmp 0x331a
xorl %eax, %eax
subq %rax, %rdx
jbe 0x3334
shlq $0x3, %rax
addq (%rdi), %rax
shlq $0x3, %rdx
movq %rax, %rdi
xorl %esi, %esi
jmp 0x1090
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
cmpq %rcx, %rax
cmovbq %rax, %rcx
testq %rcx, %rcx
je 0x33c6
pushq %r14
pushq %rbx
movq (%rdi), %rdx
movq (%rsi), %rsi
xorl %edi, %edi
movabsq $0x5555555555555555, %r8 # imm = 0x5555555555555555
movabsq $0x3333333333333333, %r9 # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f, %r10 # imm = 0xF0F0F0F0F0F0F0F
movabsq $0x101010101010101, %r11 # imm = 0x101010101010101
xorl %eax, %eax
movq (%rsi,%rdi,8), %rbx
andq (%rdx,%rdi,8), %rbx
movq %rbx, %r14
shrq %r14
andq %r8, %r14
subq %r14, %rbx
movq %rbx, %r14
andq %r9, %r14
shrq $0x2, %rbx
andq %r9, %rbx
addq %r14, %rbx
movq %rbx, %r14
shrq $0x4, %r14
addq %rbx, %r14
andq %r10, %r14
imulq %r11, %r14
shrq $0x38, %r14
addq %r14, %rax
incq %rdi
cmpq %rdi, %rcx
jne 0x337e
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
je 0x33f8
movq (%rsi), %rcx
movq (%rdi), %rdx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
notq %rdi
andq %rdi, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x33e5
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
movabsq $0x5555555555555555, %r8 # imm = 0x5555555555555555
movabsq $0x3333333333333333, %r9 # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f, %r10 # imm = 0xF0F0F0F0F0F0F0F
movabsq $0x101010101010101, %r11 # imm = 0x101010101010101
testq %rdx, %rdx
je 0x3490
movq (%rdi), %rbx
movq (%rsi), %rsi
xorl %eax, %eax
xorl %r14d, %r14d
movq (%rsi,%r14,8), %r15
notq %r15
andq (%rbx,%r14,8), %r15
movq %r15, %r12
shrq %r12
andq %r8, %r12
subq %r12, %r15
movq %r15, %r12
andq %r9, %r12
shrq $0x2, %r15
andq %r9, %r15
addq %r12, %r15
movq %r15, %r12
shrq $0x4, %r12
addq %r15, %r12
andq %r10, %r12
imulq %r11, %r12
shrq $0x38, %r12
addq %r12, %rax
incq %r14
cmpq %r14, %rdx
jne 0x3447
jmp 0x3494
xorl %edx, %edx
xorl %eax, %eax
cmpq %rcx, %rdx
jae 0x34dc
movq (%rdi), %rsi
movq (%rsi,%rdx,8), %rdi
movq %rdi, %rbx
shrq %rbx
andq %r8, %rbx
subq %rbx, %rdi
movq %rdi, %rbx
andq %r9, %rbx
shrq $0x2, %rdi
andq %r9, %rdi
addq %rbx, %rdi
movq %rdi, %rbx
shrq $0x4, %rbx
addq %rdi, %rbx
andq %r10, %rbx
imulq %r11, %rbx
shrq $0x38, %rbx
addq %rbx, %rax
incq %rdx
cmpq %rdx, %rcx
jne 0x349c
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
je 0x3521
movq (%r14), %rcx
movq (%r15), %rdx
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
xorq %r8, (%rdx,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x3511
movb $0x1, %bpl
movq %rsi, %r12
subq %rbx, %r12
jbe 0x355b
xorl %ebp, %ebp
movq %r15, %rdi
xorl %edx, %edx
callq 0x29aa
testb %al, %al
je 0x355b
shlq $0x3, %rbx
movq (%r15), %rdi
addq %rbx, %rdi
addq (%r14), %rbx
shlq $0x3, %r12
movq %rbx, %rsi
movq %r12, %rdx
callq 0x10b0
movb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %r8
cmpq %r8, %rdx
movq %r8, %rcx
cmovbq %rdx, %rcx
testq %rcx, %rcx
je 0x3600
movq (%rdi), %r9
movq (%rsi), %r10
xorl %eax, %eax
movabsq $0x5555555555555555, %r11 # imm = 0x5555555555555555
movabsq $0x3333333333333333, %rbx # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f, %r14 # imm = 0xF0F0F0F0F0F0F0F
movabsq $0x101010101010101, %r15 # imm = 0x101010101010101
xorl %r12d, %r12d
movq (%r10,%r12,8), %r13
xorq (%r9,%r12,8), %r13
movq %r13, %rbp
shrq %rbp
andq %r11, %rbp
subq %rbp, %r13
movq %r13, %rbp
andq %rbx, %rbp
shrq $0x2, %r13
andq %rbx, %r13
addq %rbp, %r13
movq %r13, %rbp
shrq $0x4, %rbp
addq %r13, %rbp
andq %r14, %rbp
imulq %r15, %rbp
shrq $0x38, %rbp
addq %rbp, %rax
incq %r12
cmpq %r12, %rcx
jne 0x35ba
jmp 0x3604
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %r8, %rdx
jae 0x367f
cmpq %r8, %rcx
jae 0x36ef
movq (%rsi), %rdx
movabsq $0x5555555555555555, %rsi # imm = 0x5555555555555555
movabsq $0x3333333333333333, %rdi # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f, %r9 # imm = 0xF0F0F0F0F0F0F0F
movabsq $0x101010101010101, %r10 # imm = 0x101010101010101
movq (%rdx,%rcx,8), %r11
movq %r11, %rbx
shrq %rbx
andq %rsi, %rbx
subq %rbx, %r11
movq %r11, %rbx
andq %rdi, %rbx
shrq $0x2, %r11
andq %rdi, %r11
addq %rbx, %r11
movq %r11, %rbx
shrq $0x4, %rbx
addq %r11, %rbx
andq %r9, %rbx
imulq %r10, %rbx
shrq $0x38, %rbx
addq %rbx, %rax
incq %rcx
cmpq %rcx, %r8
jne 0x363d
jmp 0x36ef
cmpq %rdx, %rcx
jae 0x36ef
movq (%rdi), %rsi
movabsq $0x5555555555555555, %rdi # imm = 0x5555555555555555
movabsq $0x3333333333333333, %r8 # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f, %r9 # imm = 0xF0F0F0F0F0F0F0F
movabsq $0x101010101010101, %r10 # imm = 0x101010101010101
movq (%rsi,%rcx,8), %r11
movq %r11, %rbx
shrq %rbx
andq %rdi, %rbx
subq %rbx, %r11
movq %r11, %rbx
andq %r8, %rbx
shrq $0x2, %r11
andq %r8, %r11
addq %rbx, %r11
movq %r11, %rbx
shrq $0x4, %rbx
addq %r11, %rbx
andq %r9, %rbx
imulq %r10, %rbx
shrq $0x38, %rbx
addq %rbx, %rax
incq %rcx
cmpq %rcx, %rdx
jne 0x36af
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
incq %rax
cmpq $0x1, %rax
je 0x3721
movq (%rbx), %rcx
leaq -0x1(%rax), %rsi
cmpq $0x0, -0x10(%rcx,%rax,8)
movq %rsi, %rax
je 0x3707
jmp 0x3723
xorl %esi, %esi
movb $0x1, %bpl
cmpq %rsi, 0x10(%rbx)
je 0x3754
movq %rsi, 0x10(%rbx)
movq %rsi, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x3, %rsi
callq 0x10d0
testq %rax, %rax
je 0x374a
movq %rax, (%rbx)
jmp 0x3754
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_O1/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
xorl %esi, %esi
movb (%rdx,%rsi), %r8b
movb %r8b, (%rax,%rsi,4)
incq %rsi
cmpq $0x4, %rsi
jne 0x1199
incq %rcx
addq $0x4, %rdx
incq %rax
cmpq $0x4, %rcx
jne 0x1197
xorl %ecx, %ecx
leaq 0x1e4d(%rip), %rax      # 0x3010
movq 0x3e2e(%rip), %rdx      # 0x4ff8
movzbl -0x10(%rsp,%rcx), %esi
movzbl (%rsi,%rax), %esi
shll $0x8, %esi
leal -0x1(%rcx), %r8d
andl $0x3, %r8d
movzbl -0x4(%rsp,%r8), %r8d
movzbl (%r8,%rax), %r8d
shll $0x8, %r8d
movb 0x1(%rdx,%r8), %r11b
xorb 0x2(%rdx,%rsi), %r11b
movq %rcx, %r9
xorq $0x2, %r9
movzbl -0x8(%rsp,%r9), %r9d
movzbl (%r9,%rax), %r10d
shll $0x8, %r10d
xorb 0x1(%rdx,%r10), %r11b
leaq 0x1(%rcx), %r9
movl %r9d, %ebx
andl $0x3, %ebx
movzbl -0xc(%rsp,%rbx), %ebx
movzbl (%rbx,%rax), %ebx
shll $0x8, %ebx
xorb 0x3(%rdx,%rbx), %r11b
movb %r11b, (%rdi,%rcx,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,%rcx,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,%rcx,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,%rcx,4)
movq %r9, %rcx
cmpq $0x4, %r9
jne 0x11ca
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
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
decb %cl
jne 0x1588
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7480
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7090
leaq 0x8(%rsp), %rdi
callq 0x7980
leaq 0x105fb(%rip), %rax     # 0x18158
movq %rax, (%rbx)
leaq 0x630(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x7480
leaq 0x648(%rbx), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x7480
movzwl 0x11951(%rip), %eax     # 0x194da
movw %ax, 0x20(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x7550
movq %r13, %rdi
movq %r15, %rsi
callq 0x7550
movq %rbx, %rdi
callq 0x7bf6
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x7bdd
movq %rax, %r15
jmp 0x7be5
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x7980
jmp 0x7bed
movq %rax, %r15
movq %r13, %rdi
callq 0x7980
movq %r14, %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7960
movq %r15, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O1/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)
cmpl $0x0, 0x28(%rdi)
jle 0x8846
movq (%rsp), %rax
leaq 0x20(%rax), %r15
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
leaq 0x30(%rsp), %r12
movq %r15, %rdi
movl %ebp, %esi
callq 0xa81a
movq (%rax), %r14
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x74e0
testb %al, %al
jne 0x87a1
leaq 0x650(%r14), %rdi
xorl %esi, %esi
callq 0x76f0
testb %al, %al
je 0x8837
movq %r13, %rdi
leaq 0x9bb4(%rip), %rsi      # 0x1235f
callq 0x77f0
leaq 0x650(%r14), %rdx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x7570
movq %rax, %rbx
movq %r13, %rdi
callq 0x7980
movq %r13, %rdi
leaq 0x986c(%rip), %rsi      # 0x12045
callq 0x77f0
movslq 0x630(%r14), %rsi
movq %r12, %rdi
callq 0x7220
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x73c0
movq %r12, %rdi
callq 0x7980
movq %r13, %rdi
callq 0x7980
movq %r13, %rdi
leaq 0x9833(%rip), %rsi      # 0x12048
callq 0x77f0
addq $0x638, %r14            # imm = 0x638
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x73c0
movq %r13, %rdi
callq 0x7980
incl %ebp
movq (%rsp), %rax
cmpl 0x28(%rax), %ebp
jl 0x876e
movq (%rsp), %rax
cmpl $0x0, 0xd8(%rax)
jle 0x8905
movq (%rsp), %rax
leaq 0xd0(%rax), %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x18(%rsp), %r13
leaq 0x30(%rsp), %r12
incl %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x9bf4
movq (%rax), %rbx
movq %r13, %rdi
leaq 0x97c5(%rip), %rsi      # 0x1204f
callq 0x77f0
movq %r12, %rdi
xorl %esi, %esi
callq 0x7480
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7570
movq %rax, %r15
movq %r12, %rdi
callq 0x7980
movq %r13, %rdi
callq 0x7980
movq %r13, %rdi
leaq 0x977a(%rip), %rsi      # 0x12040
callq 0x77f0
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x73c0
movq %r13, %rdi
callq 0x7980
movq %rbx, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
callq 0x8734
movq (%rsp), %rax
movl 0xd8(%rax), %eax
decl %eax
cmpl %eax, %ebp
jl 0x8871
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x892f
jmp 0x8920
jmp 0x892f
jmp 0x892f
jmp 0x892f
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x7980
jmp 0x8932
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7290
// File: /workspace/github_c_makefile_star2_O1/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 0x8f90
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0xf67b(%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 0x8f85
decl %ebp
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0x9216
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x20(%rax)
testb %al, %al
je 0x8f5a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x915e
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %r12
cmpq $0x0, 0x10(%rdi)
jne 0x8ff6
movl $0x58, %edi
callq 0x7530
movq %rax, %r13
movq %rax, %rdi
callq 0x7130
leaq 0xf6ee(%rip), %rax      # 0x186c0
movq %rax, 0x40(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r13)
leaq 0xf63b(%rip), %rax      # 0x18620
movq %rax, (%r13)
movq %r13, 0x10(%r12)
movq %r13, %rdi
callq 0x72b0
movq 0x10(%r12), %r12
movl $0x20, %edi
callq 0x7530
leaq 0xf5b4(%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 %r12, %rdi
callq 0xa67e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r13, %rdi
callq 0x70a0
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x18(%rdi), %rax
orq 0x10(%rdi), %rax
je 0x90ed
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x907e
addq $0x1c, %rdi
callq 0x77e0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x90ac
xorl %ebp, %ebp
cmpl 0x8(%rdi), %ebp
jge 0x90ac
movl %ebp, %esi
callq 0x9216
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
incl %ebp
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
jne 0x9089
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x90d7
xorl %ebp, %ebp
cmpl 0x8(%rdi), %ebp
jge 0x90d7
movl %ebp, %esi
callq 0x9216
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
incl %ebp
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
jne 0x90b7
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
popq %rbx
popq %r14
popq %rbp
je 0x90ed
addq $0x1c, %rdi
jmp 0x7120
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x91b2
movl %esi, %ebp
cmpl %esi, 0x8(%rdi)
jle 0x91b2
movl %ebp, %esi
callq 0x9216
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9189
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 0x91b2
testq %rdi, %rdi
je 0x91aa
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x920e
movl %esi, %ebp
cmpl %esi, 0x8(%rdi)
jle 0x920e
movl %ebp, %esi
callq 0x9216
movq (%rax), %rdi
testq %rdi, %rdi
je 0x91e5
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 0x920e
testq %rdi, %rdi
je 0x9206
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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)
cmpb $0x1, 0x30(%rdi)
jne 0x9238
movq 0x38(%r14), %rdi
callq 0x7240
leaq 0x102c1(%rip), %r15     # 0x19500
testl %ebx, %ebx
js 0x925a
cmpl %ebx, 0x8(%r14)
jle 0x925a
movq 0x48(%r14), %rax
movq (%rax), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %r15
movl %ebx, 0x14(%r14)
leaq 0x8(%rsp), %rdi
callq 0x9272
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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)
cmpb $0x1, 0x30(%rdi)
jne 0x92cf
movq 0x38(%r14), %rdi
callq 0x74d0
movl 0x8(%r14), %eax
cmpl %ebp, %eax
setle %cl
testl %ebp, %ebp
sets %dl
orb %cl, %dl
jne 0x92ef
cmpl %ebx, %eax
setle %al
testl %ebx, %ebx
sets %cl
orb %al, %cl
je 0x92f3
xorl %ebx, %ebx
jmp 0x934f
movq 0x48(%r14), %rax
movq (%rax), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %r15
movl %ebx, %edx
movl %ebx, %r12d
subl %ebp, %edx
jge 0x931e
leaq (%rax,%r12,8), %rsi
leaq (%rax,%r12,8), %rdi
addq $0x8, %rdi
movl %ebp, %eax
subl %ebx, %eax
movslq %eax, %rdx
jmp 0x932d
leaq (%rax,%rcx,8), %rdi
leaq (%rax,%rcx,8), %rsi
addq $0x8, %rsi
movslq %edx, %rdx
shlq $0x3, %rdx
callq 0x70e0
movq 0x48(%r14), %rax
movq (%rax), %rax
movq %r15, (%rax,%r12,8)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x76d0
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x956a
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 0x956a
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O1/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)
cmpb $0x1, 0x30(%rdi)
jne 0x939f
movq 0x38(%rbx), %rdi
callq 0x74d0
movl 0x8(%rbx), %eax
cmpl %ebp, %eax
setle %cl
testl %ebp, %ebp
sets %dl
orb %cl, %dl
je 0x93b4
xorl %ebx, %ebx
jmp 0x9428
cmpl $0x1, %eax
jne 0x93c4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
jmp 0x9426
movq 0x48(%rbx), %rax
movq (%rax), %rax
movl %ebp, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x93e1
movl $0x8, %esi
callq 0x70a0
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x93ef
movq (%rax), %rcx
jmp 0x93f1
xorl %ecx, %ecx
leaq (%rcx,%r14,8), %rdi
testq %rax, %rax
je 0x93ff
movq (%rax), %rax
jmp 0x9401
xorl %eax, %eax
leaq (%rax,%r14,8), %rsi
addq $0x8, %rsi
movl %ebp, %eax
notl %eax
addl 0x8(%rbx), %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x70e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7600
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x956a
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x956a
movq %rbx, %rdi
callq 0x7290
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, (%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0x946c
movq 0x38(%rbx), %rdi
callq 0x74d0
cmpl $0x0, 0x8(%rbx)
je 0x94b6
cmpl $0x0, 0x8(%rbx)
jle 0x94a1
xorl %r14d, %r14d
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x9495
movl $0x8, %esi
callq 0x70a0
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x947b
leaq 0x40(%rbx), %rdi
callq 0x9528
movq %rbx, %rdi
callq 0x71a0
movl %eax, %ebx
jmp 0x94b8
movb $0x1, %bl
movq %rsp, %rdi
callq 0x956a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x956a
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x955f
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x955f
addq $0x8, %rbx
movq %r14, %rdi
callq 0x75c0
movl $0x8, %esi
movq %r14, %rdi
callq 0x70a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
cmpl $-0x1, %ebp
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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)
cmpb $0x1, 0x30(%rdi)
jne 0x9b5e
movq 0x38(%r14), %rdi
callq 0x7240
leaq 0xf9a3(%rip), %r15      # 0x19508
testl %ebx, %ebx
js 0x9b80
cmpl %ebx, 0x8(%r14)
jle 0x9b80
movq 0x48(%r14), %rax
movq (%rax), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %r15
movl %ebx, 0x14(%r14)
leaq 0x8(%rsp), %rdi
callq 0x9272
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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)
cmpb $0x1, 0x30(%rdi)
jne 0x9d26
movq 0x38(%rbx), %rdi
callq 0x74d0
movl 0x8(%rbx), %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x70b0
movl %eax, %ebp
testb %al, %al
je 0x9d87
cmpl %r15d, 0x50(%rbx)
jne 0x9d69
leaq 0x40(%rbx), %rdi
cvtsi2sd %r15d, %xmm0
mulsd 0x82dc(%rip), %xmm0     # 0x12030
movsd 0x82dc(%rip), %xmm1     # 0x12038
maxsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
callq 0x9db0
movl $0x8, %edi
callq 0x7530
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 0x956a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x956a
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x9e0d
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, %ebp
jge 0x9ddf
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x9de5
leal (,%rbx,8), %esi
callq 0x71b0
jmp 0x9e05
movl %ebx, 0x10(%r14)
jmp 0x9e0d
movl $0x8, %edi
callq 0x7530
movq %rax, %r15
leal (,%rbx,8), %esi
movq %rax, %rdi
callq 0x7590
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
movl $0x8, %esi
movq %r15, %rdi
callq 0x70a0
movq %rbx, %rdi
callq 0x7290
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/tools/translator/../../include/smooth/templates/array/arraybackend.h
// Function: smooth::ArrayBackend<smooth::GUI::Tree*>::Add(smooth::GUI::Tree* const&)
Int Add(const s &value)
			{
				WriteLock	 lock(*this);
				Int		 index = greatestIndex + 1;

				if (!Add(value, index))	index = -1;

				return index;
			}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0xa170
movq 0x38(%r14), %rdi
callq 0x74d0
movl 0xc(%r14), %ebp
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0xa1b8
testb %al, %al
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmovnel %ebp, %ebx
leaq 0x8(%rsp), %rdi
callq 0x956a
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x956a
movq %rbx, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x7480
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7090
movq %rsp, %rdi
callq 0x7980
leaq 0xde38(%rip), %rax      # 0x186f0
movq %rax, (%rbx)
leaq 0x638(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x7480
leaq 0x650(%rbx), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x7480
movzwl 0xec44(%rip), %eax      # 0x19528
movw %ax, 0x20(%rbx)
movl %ebp, 0x630(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x7550
movq %r13, %rdi
movq %r15, %rsi
callq 0x7550
movq %rbx, %rdi
callq 0xa956
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0xa93d
movq %rax, %r15
jmp 0xa945
movq %rax, %r15
movq %rsp, %rdi
callq 0x7980
jmp 0xa94d
movq %rax, %r15
movq %r13, %rdi
callq 0x7980
movq %r14, %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7960
movq %r15, %rdi
callq 0x7290
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x78d0
movq 0xe562(%rip), %rdi      # 0x18fc8
movq %rbx, %rsi
callq 0x7550
leaq 0x68(%rsp), %rdi
callq 0x7670
leaq 0x38(%rsp), %rdi
callq 0x78b0
leaq 0x38(%rsp), %rdi
callq 0x7980
leaq 0x20(%rsp), %rdi
callq 0x7320
leaq 0x20(%rsp), %rdi
callq 0x7980
callq 0x73e0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testb %al, %al
je 0xab46
leaq 0xc0(%rsp), %rdi
callq 0x7360
leaq 0x782b(%rip), %rsi      # 0x122f1
leaq 0x8(%rsp), %rdi
callq 0x77f0
leaq 0xc0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7700
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x7980
leaq 0xc0(%rsp), %rdi
callq 0x7980
testb %bpl, %bpl
je 0xab07
callq 0x75d0
jmp 0xab46
movq 0xe472(%rip), %rdi      # 0x18f80
xorl %esi, %esi
callq 0x10a0c
leaq 0xc0(%rsp), %rdi
movq %rax, %rsi
callq 0xaba8
leaq 0xc0(%rsp), %rdi
callq 0x7780
movl %eax, %ebx
leaq 0xc0(%rsp), %rdi
callq 0xeef2
callq 0x75d0
leaq 0x50(%rsp), %rdi
callq 0x76e0
movl %ebx, %eax
addq $0x838, %rsp            # imm = 0x838
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0xeef2
jmp 0xab96
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7980
jmp 0xab80
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x7980
jmp 0xab96
jmp 0xab93
jmp 0xab93
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x76e0
movq %rbx, %rdi
callq 0x7290
// File: /workspace/github_c_makefile_star2_O1/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 0x74e0
testb %al, %al
je 0xc85b
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc9aa
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 0x74f0
movq 0x608(%rbx), %rdi
movq (%rdi), %rax
callq *0x90(%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %al, %al
je 0xc8eb
movq 0x608(%rbx), %rdi
addq $0x38, %rdi
xorl %esi, %esi
callq 0x9216
movq (%rax), %rax
movq 0x5d0(%rax), %rax
movl (%rax), %ebp
movq 0x600(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq 0x608(%rbx), %rsi
movq %rbx, %rdi
callq 0xf344
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 0x7380
movq 0x608(%rbx), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x8c12
leaq 0x8(%rsp), %rdi
callq 0x7980
movq 0x608(%rbx), %rdi
addq $0x38, %rdi
xorl %esi, %esi
callq 0x9216
movq (%rax), %rdi
movl %ebp, %esi
callq 0x7710
movq 0x608(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq %r14, %rdi
callq 0x7900
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 0x7980
movq %rbx, %rdi
callq 0x7290
// File: /workspace/github_c_makefile_star2_O1/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 0x7480
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7980
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 0x74f0
movq 0x608(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq 0x608(%rbx), %rsi
movq %rbx, %rdi
callq 0xf344
movq 0x600(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq %r14, %rdi
callq 0x7900
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7980
movq %rbx, %rdi
callq 0x7290