LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ivanzamanov[P]kmeans/src/stemmer/stemmer.cpp
// Function: processFile(int, int, stat*)
void processFile(int inputFD, int outputFD, struct stat* const fileStat) {
	char* fullData = 0;
	readFullData(inputFD, &fullData);

	char* buffer = new char[4096];
	int offset = 0;
	readToken(fullData, offset, buffer, 4096);
	stemToken(buffer);
	writeToken(buffer, outputFD);
	while(readToken(fullData, offset, buffer, 4096)) {
		writeToken(" ", outputFD);
		stemToken(buffer);
		writeToken(buffer, outputFD);
	}
	delete fullData;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movl 0x34(%rsp), %edi
leaq 0x20(%rsp), %rsi
callq 0x2590
movl $0x1000, %edi           # imm = 0x1000
callq 0x1030
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x14(%rsp), %rsi
movl $0x1000, %ecx           # imm = 0x1000
callq 0x2440
movq 0x18(%rsp), %rdi
callq 0x1460
movq 0x18(%rsp), %rdi
movl 0x30(%rsp), %esi
callq 0x2300
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x14(%rsp), %rsi
movl $0x1000, %ecx           # imm = 0x1000
callq 0x2440
testb $0x1, %al
jne 0x140f
jmp 0x1439
movl 0x30(%rsp), %esi
leaq 0x1c1a(%rip), %rdi      # 0x3034
callq 0x2300
movq 0x18(%rsp), %rdi
callq 0x1460
movq 0x18(%rsp), %rdi
movl 0x30(%rsp), %esi
callq 0x2300
jmp 0x13f0
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1453
movq 0x8(%rsp), %rdi
callq 0x1090
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ivanzamanov[P]kmeans/src/common/stem.cpp
// Function: stem(char*, int, int)
int stem(char * p, int i, int j)
{  b = p; k = j; k0 = i; /* copy the parameters into statics */
   if (k <= k0+1) return k; /*-DEPARTURE-*/

   /* With this line, strings of length 1 or 2 don't go through the
      stemming process, although no mention is made of this in the
      published algorithm. Remove the line to match the published
      algorithm. */

   step1ab(); step1c(); step2(); step3(); step4(); step5();
   return k;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x3bb4(%rip)      # 0x5080
movl (%rsp), %eax
movl %eax, 0x3bb3(%rip)      # 0x5088
movl 0x4(%rsp), %eax
movl %eax, 0x3bad(%rip)      # 0x508c
movl 0x3ba3(%rip), %eax      # 0x5088
movl 0x3ba1(%rip), %ecx      # 0x508c
addl $0x1, %ecx
cmpl %ecx, %eax
jg 0x14fe
movl 0x3b90(%rip), %eax      # 0x5088
movl %eax, 0x14(%rsp)
jmp 0x1526
callq 0x1530
callq 0x1720
callq 0x1750
callq 0x1a70
callq 0x1ba0
callq 0x1df0
movl 0x3b66(%rip), %eax      # 0x5088
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: ivanzamanov[P]kmeans/src/common/stem.cpp
// Function: step1ab()
static void step1ab()
{  if (b[k] == 's')
   {  if (ends("\04" "sses")) k -= 2; else
      if (ends("\03" "ies")) setto("\01" "i"); else
      if (b[k-1] != 's') k--;
   }
   if (ends("\03" "eed")) { if (m() > 0) k--; } else
   if ((ends("\02" "ed") || ends("\03" "ing")) && vowelinstem())
   {  k = j;
      if (ends("\02" "at")) setto("\03" "ate"); else
      if (ends("\02" "bl")) setto("\03" "ble"); else
      if (ends("\02" "iz")) setto("\03" "ize"); else
      if (doublec(k))
      {  k--;
         {  int ch = b[k];
            if (ch == 'l' || ch == 's' || ch == 'z') k++;
         }
      }
      else if (m() == 1 && cvc(k)) setto("\01" "e");
   }
}

// Assembly:
pushq %rax
movq 0x3b48(%rip), %rax      # 0x5080
movslq 0x3b49(%rip), %rcx      # 0x5088
movsbl (%rax,%rcx), %eax
cmpl $0x73, %eax
jne 0x15ba
leaq 0x1bdf(%rip), %rdi      # 0x312e
callq 0x1ea0
cmpl $0x0, %eax
je 0x156a
movl 0x3b29(%rip), %eax      # 0x5088
subl $0x2, %eax
movl %eax, 0x3b20(%rip)      # 0x5088
jmp 0x15b8
leaq 0x1bc3(%rip), %rdi      # 0x3134
callq 0x1ea0
cmpl $0x0, %eax
je 0x1589
leaq 0x1bb7(%rip), %rdi      # 0x3139
callq 0x1f70
jmp 0x15b6
movq 0x3af0(%rip), %rax      # 0x5080
movl 0x3af2(%rip), %ecx      # 0x5088
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x73, %eax
je 0x15b4
movl 0x3add(%rip), %eax      # 0x5088
addl $-0x1, %eax
movl %eax, 0x3ad4(%rip)      # 0x5088
jmp 0x15b6
jmp 0x15b8
jmp 0x15ba
leaq 0x1b7b(%rip), %rdi      # 0x313c
callq 0x1ea0
cmpl $0x0, %eax
je 0x15e9
callq 0x1fd0
cmpl $0x0, %eax
jle 0x15e4
movl 0x3aad(%rip), %eax      # 0x5088
addl $-0x1, %eax
movl %eax, 0x3aa4(%rip)      # 0x5088
jmp 0x171c
leaq 0x1b51(%rip), %rdi      # 0x3141
callq 0x1ea0
cmpl $0x0, %eax
jne 0x160f
leaq 0x1b44(%rip), %rdi      # 0x3145
callq 0x1ea0
cmpl $0x0, %eax
je 0x171a
callq 0x20c0
cmpl $0x0, %eax
je 0x171a
movl 0x3a6d(%rip), %eax      # 0x5090
movl %eax, 0x3a5f(%rip)      # 0x5088
leaq 0x1b1a(%rip), %rdi      # 0x314a
callq 0x1ea0
cmpl $0x0, %eax
je 0x164b
leaq 0x1b0d(%rip), %rdi      # 0x314e
callq 0x1f70
jmp 0x1718
leaq 0x1b01(%rip), %rdi      # 0x3153
callq 0x1ea0
cmpl $0x0, %eax
je 0x166d
leaq 0x1af4(%rip), %rdi      # 0x3157
callq 0x1f70
jmp 0x1716
leaq 0x1ae8(%rip), %rdi      # 0x315c
callq 0x1ea0
cmpl $0x0, %eax
je 0x168f
leaq 0x1adb(%rip), %rdi      # 0x3160
callq 0x1f70
jmp 0x1714
movl 0x39f3(%rip), %edi      # 0x5088
callq 0x2110
cmpl $0x0, %eax
je 0x16ea
movl 0x39e3(%rip), %eax      # 0x5088
addl $-0x1, %eax
movl %eax, 0x39da(%rip)      # 0x5088
movq 0x39cb(%rip), %rax      # 0x5080
movslq 0x39cc(%rip), %rcx      # 0x5088
movsbl (%rax,%rcx), %eax
movl %eax, 0x4(%rsp)
cmpl $0x6c, 0x4(%rsp)
je 0x16d9
cmpl $0x73, 0x4(%rsp)
je 0x16d9
cmpl $0x7a, 0x4(%rsp)
jne 0x16e8
movl 0x39a9(%rip), %eax      # 0x5088
addl $0x1, %eax
movl %eax, 0x39a0(%rip)      # 0x5088
jmp 0x1712
callq 0x1fd0
cmpl $0x1, %eax
jne 0x1710
movl 0x398e(%rip), %edi      # 0x5088
callq 0x2180
cmpl $0x0, %eax
je 0x1710
leaq 0x1a5a(%rip), %rdi      # 0x3165
callq 0x1f70
jmp 0x1712
jmp 0x1714
jmp 0x1716
jmp 0x1718
jmp 0x171a
jmp 0x171c
popq %rax
retq
nop
// File: ivanzamanov[P]kmeans/src/common/stem.cpp
// Function: step3()
static void step3() { switch (b[k])
{
    case 'e': if (ends("\05" "icate")) { r("\02" "ic"); break; }
              if (ends("\05" "ative")) { r("\00" ""); break; }
              if (ends("\05" "alize")) { r("\02" "al"); break; }
              break;
    case 'i': if (ends("\05" "iciti")) { r("\02" "ic"); break; }
              break;
    case 'l': if (ends("\04" "ical")) { r("\02" "ic"); break; }
              if (ends("\03" "ful")) { r("\00" ""); break; }
              break;
    case 's': if (ends("\04" "ness")) { r("\00" ""); break; }
              break;
} }

// Assembly:
pushq %rax
movq 0x3608(%rip), %rax      # 0x5080
movslq 0x3609(%rip), %rcx      # 0x5088
movsbl (%rax,%rcx), %eax
addl $-0x65, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0xe, %eax
ja 0x1b96
movq (%rsp), %rax
leaq 0x15e8(%rip), %rcx      # 0x3088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x177f(%rip), %rdi      # 0x322f
callq 0x1ea0
cmpl $0x0, %eax
je 0x1acb
leaq 0x1775(%rip), %rdi      # 0x3236
callq 0x22e0
jmp 0x1b96
leaq 0x1768(%rip), %rdi      # 0x323a
callq 0x1ea0
cmpl $0x0, %eax
je 0x1aed
leaq 0x1649(%rip), %rdi      # 0x312c
callq 0x22e0
jmp 0x1b96
leaq 0x174d(%rip), %rdi      # 0x3241
callq 0x1ea0
cmpl $0x0, %eax
je 0x1b0f
leaq 0x16a6(%rip), %rdi      # 0x31ab
callq 0x22e0
jmp 0x1b96
jmp 0x1b96
leaq 0x172d(%rip), %rdi      # 0x3248
callq 0x1ea0
cmpl $0x0, %eax
je 0x1b33
leaq 0x170a(%rip), %rdi      # 0x3236
callq 0x22e0
jmp 0x1b96
jmp 0x1b96
leaq 0x1713(%rip), %rdi      # 0x324f
callq 0x1ea0
cmpl $0x0, %eax
je 0x1b54
leaq 0x16e9(%rip), %rdi      # 0x3236
callq 0x22e0
jmp 0x1b96
leaq 0x16a5(%rip), %rdi      # 0x3200
callq 0x1ea0
cmpl $0x0, %eax
je 0x1b73
leaq 0x15c0(%rip), %rdi      # 0x312c
callq 0x22e0
jmp 0x1b96
jmp 0x1b96
leaq 0x16d9(%rip), %rdi      # 0x3255
callq 0x1ea0
cmpl $0x0, %eax
je 0x1b94
leaq 0x159f(%rip), %rdi      # 0x312c
callq 0x22e0
jmp 0x1b96
jmp 0x1b96
popq %rax
retq
nopl (%rax,%rax)
// File: ivanzamanov[P]kmeans/src/common/stem.cpp
// Function: step5()
static void step5()
{  j = k;
   if (b[k] == 'e')
   {  int a = m();
      if (a > 1 || (a == 1 && !cvc(k-1))) k--;
   }
   if (b[k] == 'l' && doublec(k) && m() > 1) k--;
}

// Assembly:
pushq %rax
movl 0x3291(%rip), %eax      # 0x5088
movl %eax, 0x3293(%rip)      # 0x5090
movq 0x327c(%rip), %rax      # 0x5080
movslq 0x327d(%rip), %rcx      # 0x5088
movsbl (%rax,%rcx), %eax
cmpl $0x65, %eax
jne 0x1e4f
callq 0x1fd0
movl %eax, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jg 0x1e3e
cmpl $0x1, 0x4(%rsp)
jne 0x1e4d
movl 0x3257(%rip), %edi      # 0x5088
subl $0x1, %edi
callq 0x2180
cmpl $0x0, %eax
jne 0x1e4d
movl 0x3244(%rip), %eax      # 0x5088
addl $-0x1, %eax
movl %eax, 0x323b(%rip)      # 0x5088
jmp 0x1e4f
movq 0x322a(%rip), %rax      # 0x5080
movslq 0x322b(%rip), %rcx      # 0x5088
movsbl (%rax,%rcx), %eax
cmpl $0x6c, %eax
jne 0x1e8f
movl 0x321c(%rip), %edi      # 0x5088
callq 0x2110
cmpl $0x0, %eax
je 0x1e8f
callq 0x1fd0
cmpl $0x1, %eax
jle 0x1e8f
movl 0x3202(%rip), %eax      # 0x5088
addl $-0x1, %eax
movl %eax, 0x31f9(%rip)      # 0x5088
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: ivanzamanov[P]kmeans/src/common/stem.cpp
// Function: ends(char const*)
static int ends(const char * s)
{  int length = s[0];
   if (s[length] != b[k]) return FALSE; /* tiny speed-up */
   if (length > k-k0+1) return FALSE;
   if (memcmp(b+k-length+1,s+1,length) != 0) return FALSE;
   j = k-length;
   return TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x31b6(%rip), %rcx      # 0x5080
movslq 0x31b7(%rip), %rdx      # 0x5088
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x1ee3
movl $0x0, 0x14(%rsp)
jmp 0x1f60
movl 0x4(%rsp), %eax
movl 0x319b(%rip), %ecx      # 0x5088
subl 0x3199(%rip), %ecx      # 0x508c
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0x1f04
movl $0x0, 0x14(%rsp)
jmp 0x1f60
movq 0x3175(%rip), %rdi      # 0x5080
movslq 0x3176(%rip), %rax      # 0x5088
addq %rax, %rdi
movslq 0x4(%rsp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
addq $0x1, %rdi
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
movslq 0x4(%rsp), %rdx
callq 0x1070
cmpl $0x0, %eax
je 0x1f48
movl $0x0, 0x14(%rsp)
jmp 0x1f60
movl 0x313a(%rip), %eax      # 0x5088
subl 0x4(%rsp), %eax
movl %eax, 0x3138(%rip)      # 0x5090
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: ivanzamanov[P]kmeans/src/common/stem.cpp
// Function: m()
static int m()
{  int n = 0;
   int i = k0;
   while(TRUE)
   {  if (i > j) return n;
      if (! cons(i)) break; i++;
   }
   i++;
   while(TRUE)
   {  while(TRUE)
      {  if (i > j) return n;
            if (cons(i)) break;
            i++;
      }
      i++;
      n++;
      while(TRUE)
      {  if (i > j) return n;
         if (! cons(i)) break;
         i++;
      }
      i++;
   }
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x10(%rsp)
movl 0x30aa(%rip), %eax      # 0x508c
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x30a0(%rip), %eax      # 0x5090
jle 0x1fff
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x20b5
movl 0xc(%rsp), %edi
callq 0x2220
cmpl $0x0, %eax
jne 0x200f
jmp 0x201c
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1fe6
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2029
movl 0xc(%rsp), %eax
cmpl 0x305d(%rip), %eax      # 0x5090
jle 0x203f
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x20b5
movl 0xc(%rsp), %edi
callq 0x2220
cmpl $0x0, %eax
je 0x204f
jmp 0x205c
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2029
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x3014(%rip), %eax      # 0x5090
jle 0x2088
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x20b5
movl 0xc(%rsp), %edi
callq 0x2220
cmpl $0x0, %eax
jne 0x2098
jmp 0x20a5
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2072
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2027
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: ivanzamanov[P]kmeans/src/common/stem.cpp
// Function: cvc(int)
static int cvc(int i)
{  if (i < k0+2 || !cons(i) || cons(i-1) || !cons(i-2)) return FALSE;
   {  int ch = b[i];
      if (ch == 'w' || ch == 'x' || ch == 'y') return FALSE;
   }
   return TRUE;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl 0x2efa(%rip), %ecx      # 0x508c
addl $0x2, %ecx
cmpl %ecx, %eax
jl 0x21c9
movl 0x10(%rsp), %edi
callq 0x2220
cmpl $0x0, %eax
je 0x21c9
movl 0x10(%rsp), %edi
subl $0x1, %edi
callq 0x2220
cmpl $0x0, %eax
jne 0x21c9
movl 0x10(%rsp), %edi
subl $0x2, %edi
callq 0x2220
cmpl $0x0, %eax
jne 0x21d3
movl $0x0, 0x14(%rsp)
jmp 0x220e
movq 0x2ea6(%rip), %rax      # 0x5080
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, 0xc(%rsp)
cmpl $0x77, 0xc(%rsp)
je 0x21fc
cmpl $0x78, 0xc(%rsp)
je 0x21fc
cmpl $0x79, 0xc(%rsp)
jne 0x2206
movl $0x0, 0x14(%rsp)
jmp 0x220e
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: ivanzamanov[P]kmeans/src/common/stem.cpp
// Function: cons(int)
static int cons(int i)
{  switch (b[i])
   {  case 'a': case 'e': case 'i': case 'o': case 'u': return FALSE;
      case 'y': return (i==k0) ? TRUE : !cons(i-1);
      default: return TRUE;
   }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq 0x2e51(%rip), %rax      # 0x5080
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, 0xc(%rsp)
subl $0x61, %eax
je 0x227a
jmp 0x2243
movl 0xc(%rsp), %eax
subl $0x65, %eax
je 0x227a
jmp 0x224e
movl 0xc(%rsp), %eax
subl $0x69, %eax
je 0x227a
jmp 0x2259
movl 0xc(%rsp), %eax
subl $0x6f, %eax
je 0x227a
jmp 0x2264
movl 0xc(%rsp), %eax
subl $0x75, %eax
je 0x227a
jmp 0x226f
movl 0xc(%rsp), %eax
subl $0x79, %eax
je 0x2284
jmp 0x22c2
movl $0x0, 0x14(%rsp)
jmp 0x22ca
movl 0x10(%rsp), %eax
cmpl 0x2dfe(%rip), %eax      # 0x508c
jne 0x229b
movl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x22b8
movl 0x10(%rsp), %edi
subl $0x1, %edi
callq 0x2220
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x22ca
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ivanzamanov[P]kmeans/src/common/utils.cpp
// Function: writeToken(char const*, int)
void writeToken(const char* buffer, int fd) {
	int len = strlen(buffer);
	int bytesWritten = write(fd, buffer, len);
	if(len != bytesWritten) {
		printf("Error writing token\n");
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1060
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
movslq 0x8(%rsp), %rdx
callq 0x1050
movl %eax, 0x4(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x4(%rsp), %eax
je 0x234a
leaq 0xf4d(%rip), %rdi       # 0x3290
movb $0x0, %al
callq 0x1040
addq $0x18, %rsp
retq
nop
// File: ivanzamanov[P]kmeans/src/common/utils.cpp
// Function: lowercaseToken(char*)
void lowercaseToken(char* token) {
	char* str = token;
	while(*str != '\0') {
		char c = *str;
		if(c >= 'A' && c <= 'Z') {
			*str = c + DIFF;
		}		
		str++;
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x23ac
movq -0x10(%rsp), %rax
movb (%rax), %al
movb %al, -0x11(%rsp)
movsbl -0x11(%rsp), %eax
cmpl $0x41, %eax
jl 0x239c
movsbl -0x11(%rsp), %eax
cmpl $0x5a, %eax
jg 0x239c
movsbl -0x11(%rsp), %eax
addl $0x20, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, (%rax)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x235f
retq
nopl (%rax)
// File: ivanzamanov[P]kmeans/src/common/utils.cpp
// Function: readToken(char const*, int&, char*, int)
bool readToken(const char* data, int& offset, char* buffer, int buffLength) {
	const char* str = data + offset;
	if(*str == '\0')
		return false;
	int leading = 0;
	while(!isAlphanumeric(*str) && *str != '\0') {
		str++;
		leading++;
	}

	int i = 0;
	while(shouldRead(*str) && i < buffLength) {
		*(buffer + i) = *str;
		i++;
		str++;
	}

	offset = offset + leading + i;
	buffer[i] = 0;
	return i > 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2483
movb $0x0, 0x47(%rsp)
jmp 0x257a
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %edi
callq 0x23b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x24b7
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x24c1
jmp 0x24dc
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x248b
movl $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %edi
callq 0x2420
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0x2500
jmp 0x250f
movl 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
setl %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x2519
jmp 0x2548
movq 0x18(%rsp), %rax
movb (%rax), %dl
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x24e4
movq 0x30(%rsp), %rax
movl (%rax), %ecx
addl 0x14(%rsp), %ecx
addl 0x10(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, 0x10(%rsp)
setg %al
andb $0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ivanzamanov[P]kmeans/src/common/utils.cpp
// Function: readFullData(int, char**)
int readFullData(int fd, char** data) {
	const int BUFF_SIZE = 4096 * 1024;
	char* buffer = new char[BUFF_SIZE];
	int bytes = 1;
	bytes = read(fd, buffer, BUFF_SIZE);
	if(bytes >= 0)
		buffer[bytes] = 0;
	*data = buffer;
	return bytes;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x400000, 0x14(%rsp)   # imm = 0x400000
movl $0x400000, %edi         # imm = 0x400000
callq 0x1030
movq %rax, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
movl 0x24(%rsp), %edi
movq 0x8(%rsp), %rsi
movl $0x400000, %edx         # imm = 0x400000
callq 0x10a0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x25e8
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
// File: jpcima[P]faustmd/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    Cmd_Args cmd;
    if (do_cmdline(cmd, argc, argv) == -1) {
        display_usage();
        return 1;
    }

    pugi::xml_document doc;
    if (call_faust(cmd.dspfile, doc, cmd.faustargs) == -1) {
        errs() << "The faust command has failed.\n";
        return 1;
    }

    if (process_document(std::cout, doc) == -1) {
        errs() << "The document could not be processed.\n";
        return 1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0x8680
movq -0x190(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x7f80
movl %eax, -0x188(%rbp)
jmp 0x7d97
movl -0x188(%rbp), %eax
cmpl $-0x1, %eax
jne 0x7dd6
callq 0x8540
jmp 0x7da9
movl $0x1, -0x4(%rbp)
movl $0x1, -0xb0(%rbp)
jmp 0x7f42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x7f5a
leaq -0x180(%rbp), %rdi
callq 0x44690
jmp 0x7de4
leaq -0x80(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xb6a0
movl %eax, -0x194(%rbp)
jmp 0x7e03
movl -0x194(%rbp), %eax
cmpl $-0x1, %eax
jne 0x7e8d
leaq -0x181(%rbp), %rdi
callq 0x86b0
jmp 0x7e1c
leaq 0x5e1e1(%rip), %rsi     # 0x66004
leaq -0x181(%rbp), %rdi
callq 0x86e0
jmp 0x7e31
leaq -0x181(%rbp), %rdi
callq 0x8720
movl $0x1, -0x4(%rbp)
movl $0x1, -0xb0(%rbp)
jmp 0x7f26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x7f34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x181(%rbp), %rdi
callq 0x8720
jmp 0x7f34
movq 0x87104(%rip), %rdi     # 0x8ef98
leaq -0x180(%rbp), %rsi
callq 0x8560
movl %eax, -0x198(%rbp)
jmp 0x7ea8
movl -0x198(%rbp), %eax
cmpl $-0x1, %eax
jne 0x7f15
leaq -0x182(%rbp), %rdi
callq 0x86b0
jmp 0x7ec1
leaq 0x5e15b(%rip), %rsi     # 0x66023
leaq -0x182(%rbp), %rdi
callq 0x8750
jmp 0x7ed6
leaq -0x182(%rbp), %rdi
callq 0x8720
movl $0x1, -0x4(%rbp)
movl $0x1, -0xb0(%rbp)
jmp 0x7f26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x182(%rbp), %rdi
callq 0x8720
jmp 0x7f34
movl $0x0, -0x4(%rbp)
movl $0x1, -0xb0(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x447f0
jmp 0x7f42
leaq -0x180(%rbp), %rdi
callq 0x447f0
jmp 0x7f5a
leaq -0xa0(%rbp), %rdi
callq 0x8790
movl -0x4(%rbp), %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
leaq -0xa0(%rbp), %rdi
callq 0x8790
movq -0xa8(%rbp), %rdi
callq 0x7a20
nopw %cs:(%rax,%rax)
// File: jpcima[P]faustmd/main.cpp
// Function: process_document(std::ostream&, pugi::xml_document const&)
static int process_document(std::ostream &out, const pugi::xml_document &doc)
{
    if (false)
        doc.save(std::cerr);

    Metadata md;
    if (extract_metadata(doc, md) == -1) {
        errs() << "Could not extract the faust metadata.\n";
        return -1;
    }

    dump_metadata(out, md);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x128(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0xae00
movq -0x148(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x37ed0
movl %eax, -0x140(%rbp)
jmp 0x859e
movl -0x140(%rbp), %eax
cmpl $-0x1, %eax
jne 0x861f
leaq -0x135(%rbp), %rdi
callq 0x86b0
jmp 0x85b7
leaq 0x5dc04(%rip), %rsi     # 0x661c2
leaq -0x135(%rbp), %rdi
callq 0xaeb0
jmp 0x85cc
leaq -0x135(%rbp), %rdi
callq 0x8720
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x13c(%rbp)
jmp 0x8642
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x130(%rbp)
movl %eax, -0x134(%rbp)
jmp 0x865a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x130(%rbp)
movl %eax, -0x134(%rbp)
leaq -0x135(%rbp), %rdi
callq 0x8720
jmp 0x865a
movq -0x10(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x39280
jmp 0x8631
movl $0x0, -0x4(%rbp)
movl $0x1, -0x13c(%rbp)
leaq -0x128(%rbp), %rdi
callq 0xaef0
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
leaq -0x128(%rbp), %rdi
callq 0xaef0
movq -0x130(%rbp), %rdi
callq 0x7a20
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jpcima[P]faustmd/./thirdparty/gsl-lite.hpp
// Function: unsigned long gsl::detail::string_length<char>(char*, unsigned long)
gsl_api inline gsl_constexpr14 std::size_t string_length( T * ptr, std::size_t max )
{
    if ( ptr == gsl_nullptr || max <= 0 )
        return 0;

    std::size_t len = 0;
    while ( len < max && ptr[len] ) // NOLINT
        ++len;

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x91fa
cmpq $0x0, -0x18(%rbp)
ja 0x9204
movq $0x0, -0x8(%rbp)
jmp 0x924c
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x21(%rbp)
jae 0x922d
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x9236
jmp 0x9244
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x920c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jpcima[P]faustmd/./thirdparty/gsl-lite.hpp
// Function: gsl::span<char>::subspan(unsigned long, unsigned long) const
span subspan( index_type offset, index_type count ) const gsl_noexcept
    {
        Expects(
            0 <= offset && offset <= this->size() &&
            0 <= count  && count <= this->size() - offset );
        return span( this->data() + offset, count );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpq -0x20(%rbp), %rcx
movb %al, -0x29(%rbp)
ja 0xa2fd
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x9510
movq -0x40(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
ja 0xa2fd
xorl %eax, %eax
xorl %ecx, %ecx
cmpq -0x28(%rbp), %rcx
movb %al, -0x29(%rbp)
ja 0xa2fd
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x9510
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq -0x20(%rbp), %rcx
cmpq %rcx, %rax
setbe %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x92d0
movq -0x38(%rbp), %rdi
callq 0xa380
movq %rax, %rsi
movq -0x20(%rbp), %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x9260
jmp 0xa32d
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x88e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jpcima[P]faustmd/call_faust.cpp
// Function: mktempdir(char*)
static int mktempdir(char *tmp)
{
    static std::minstd_rand rnd{std::random_device{}()};
    size_t tmplen = std::char_traits<char>::length(tmp);

    int ret = -1;
    while (ret == -1) {
        const char alphabet[32+1] = "0123456789abcdefghijklmnopqrstuv";
        uint32_t number = rnd();
        for (size_t i = 0; i < 6; ++i)
            tmp[tmplen - 1 - i] = alphabet[(number >> (5 * i)) & 31];
        ret = mkdir(tmp, 0700);
        if (ret == -1 && errno != EEXIST)
            return -1;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1400, %rsp           # imm = 0x1400
movq %rdi, -0x10(%rbp)
cmpb $0x0, 0x83aca(%rip)     # 0x8fa60
jne 0xbffb
leaq 0x83ac1(%rip), %rdi     # 0x8fa60
callq 0x7a70
cmpl $0x0, %eax
je 0xbffb
leaq -0x1398(%rbp), %rdi
callq 0x36db0
jmp 0xbfb7
leaq -0x1398(%rbp), %rdi
callq 0x36e50
movl %eax, -0x13f4(%rbp)
jmp 0xbfcb
movl -0x13f4(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x83a7c(%rip), %rdi     # 0x8fa58
callq 0x36e70
jmp 0xbfe3
leaq -0x1398(%rbp), %rdi
callq 0x36ea0
leaq 0x83a6a(%rip), %rdi     # 0x8fa60
callq 0x73c0
movq -0x10(%rbp), %rdi
callq 0x9ff0
movq %rax, -0x13b0(%rbp)
movl $0xffffffff, -0x13b4(%rbp) # imm = 0xFFFFFFFF
cmpl $-0x1, -0x13b4(%rbp)
jne 0xc123
leaq -0x13e0(%rbp), %rdi
leaq 0x5a5c0(%rip), %rsi     # 0x665f0
movl $0x21, %edx
callq 0x74b0
leaq 0x83a17(%rip), %rdi     # 0x8fa58
callq 0x36ed0
movl %eax, -0x13e4(%rbp)
movq $0x0, -0x13f0(%rbp)
cmpq $0x6, -0x13f0(%rbp)
jae 0xc0ee
movl -0x13e4(%rbp), %eax
imulq $0x5, -0x13f0(%rbp), %rcx
shrl %cl, %eax
andl $0x1f, %eax
movl %eax, %eax
movb -0x13e0(%rbp,%rax), %dl
movq -0x10(%rbp), %rax
movq -0x13b0(%rbp), %rcx
subq $0x1, %rcx
subq -0x13f0(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x13f0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x13f0(%rbp)
jmp 0xc057
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x13a0(%rbp)
movl %eax, -0x13a4(%rbp)
jmp 0xc0e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x13a0(%rbp)
movl %eax, -0x13a4(%rbp)
leaq -0x1398(%rbp), %rdi
callq 0x36ea0
leaq 0x83979(%rip), %rdi     # 0x8fa60
callq 0x73b0
jmp 0xc138
movq -0x10(%rbp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x7270
movl %eax, -0x13b4(%rbp)
cmpl $-0x1, -0x13b4(%rbp)
jne 0xc11e
callq 0x7090
cmpl $0x11, (%rax)
je 0xc11e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc12c
jmp 0xc015
movl -0x13b4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1400, %rsp           # imm = 0x1400
popq %rbp
retq
movq -0x13a0(%rbp), %rdi
callq 0x7a20
nopw %cs:(%rax,%rax)
// File: jpcima[P]faustmd/call_faust.cpp
// Function: execute(char**)
static int execute(char *argv[])
{
    posix_spawn_file_actions_t fa;
    if (posix_spawn_file_actions_init(&fa) == -1)
        return -1;
    auto fa_cleanup = gsl::finally([&]() { posix_spawn_file_actions_destroy(&fa); });

    posix_spawnattr_t sa;
    if (posix_spawnattr_init(&sa) == -1)
        return -1;
    auto sa_cleanup = gsl::finally([&]() { posix_spawnattr_destroy(&sa); });

    pid_t pid;
    if (posix_spawnp(&pid, argv[0], &fa, &sa, argv, environ) == -1)
        return -1;

    int status;
    if (waitpid(pid, &status, 0) == -1)
        return -1;

    if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
        return -1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x76e0
cmpl $-0x1, %eax
jne 0xc1b9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc32e
leaq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xd4f0
leaq -0x1d0(%rbp), %rdi
callq 0x7950
cmpl $-0x1, %eax
jne 0xc1f5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x1d4(%rbp)
jmp 0xc325
leaq -0x1d0(%rbp), %rax
movq %rax, -0x220(%rbp)
movq %rax, -0x1f8(%rbp)
leaq -0x1f0(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0xd530
movq -0x220(%rbp), %rcx
movq -0x10(%rbp), %r8
movq (%r8), %rsi
movq 0x82d8e(%rip), %rax     # 0x8efc0
movq (%rax), %r9
leaq -0x1fc(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x7a80
movl %eax, -0x214(%rbp)
jmp 0xc24d
movl -0x214(%rbp), %eax
cmpl $-0x1, %eax
jne 0xc29a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x1d4(%rbp)
jmp 0xc319
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x208(%rbp)
movl %eax, -0x20c(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0xd570
leaq -0x78(%rbp), %rdi
callq 0xd5c0
jmp 0xc33a
movl -0x1fc(%rbp), %edi
leaq -0x210(%rbp), %rsi
xorl %edx, %edx
callq 0x7480
movl %eax, -0x224(%rbp)
jmp 0xc2b6
movl -0x224(%rbp), %eax
cmpl $-0x1, %eax
jne 0xc2d4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x1d4(%rbp)
jmp 0xc319
movl -0x210(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0xc2f5
movl -0x210(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
je 0xc308
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x1d4(%rbp)
jmp 0xc319
movl $0x0, -0x4(%rbp)
movl $0x1, -0x1d4(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0xd570
leaq -0x78(%rbp), %rdi
callq 0xd5c0
movl -0x4(%rbp), %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x208(%rbp), %rdi
callq 0x7a20
nopw %cs:(%rax,%rax)
// File: jpcima[P]faustmd/./thirdparty/pugixml.hpp
// Function: pugi::xml_node pugi::xml_node::find_node<apply_workarounds(pugi::xml_document&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0>(apply_workarounds(pugi::xml_document&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0) const
xml_node find_node(Predicate pred) const
		{
			if (!_root) return xml_node();

			xml_node cur = first_child();

			while (cur._root && cur._root != _root)
			{
				if (pred(cur)) return cur;

				if (cur.first_child()) cur = cur.first_child();
				else if (cur.next_sibling()) cur = cur.next_sibling();
				else
				{
					while (!cur.next_sibling() && cur._root != _root) cur = cur.parent();

					if (cur._root != _root) cur = cur.next_sibling();
				}
			}

			return xml_node();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, (%rax)
jne 0xd178
leaq -0x8(%rbp), %rdi
callq 0x3ebd0
jmp 0xd2ca
movq -0x68(%rbp), %rdi
callq 0x3f9f0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x69(%rbp)
je 0xd1a2
movq -0x68(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq (%rcx), %rax
setne %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0xd1ae
jmp 0xd2c1
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x9(%rbp), %rdi
callq 0xd4a0
testb $0x1, %al
jne 0xd1c9
jmp 0xd1d6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd2ca
leaq -0x20(%rbp), %rdi
callq 0x3f9f0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3ec10
cmpq $0x0, %rax
je 0xd20c
leaq -0x20(%rbp), %rdi
callq 0x3f9f0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xd2bc
leaq -0x20(%rbp), %rdi
callq 0x3f380
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3ec10
cmpq $0x0, %rax
je 0xd23f
leaq -0x20(%rbp), %rdi
callq 0x3f380
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xd2ba
jmp 0xd241
leaq -0x20(%rbp), %rdi
callq 0x3f380
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3ec50
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x6a(%rbp)
jne 0xd265
jmp 0xd276
movq -0x68(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq (%rcx), %rax
setne %al
movb %al, -0x6a(%rbp)
movb -0x6a(%rbp), %al
testb $0x1, %al
jne 0xd27f
jmp 0xd296
leaq -0x20(%rbp), %rdi
callq 0x3f6c0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xd241
movq -0x68(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq (%rcx), %rax
je 0xd2b8
leaq -0x20(%rbp), %rdi
callq 0x3f380
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xd2ba
jmp 0xd2bc
jmp 0xd185
leaq -0x8(%rbp), %rdi
callq 0x3ebd0
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jpcima[P]faustmd/metadata.cpp
// Function: Metadata::Widget::type_from_name(gsl::basic_string_span<char const>)
Metadata::Widget::Type Metadata::Widget::type_from_name(gsl::cstring_span name)
{
    Metadata::Widget::Type t = (Metadata::Widget::Type)-1;

    if (name == "button")
        t = Type::Button;
    else if (name == "checkbox")
        t = Type::CheckBox;
    else if (name == "vslider")
        t = Type::VSlider;
    else if (name == "hslider")
        t = Type::HSlider;
    else if (name == "nentry")
        t = Type::NEntry;
    else if (name == "vbargraph")
        t = Type::VBarGraph;
    else if (name == "hbargraph")
        t = Type::HBarGraph;

    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
leaq -0x10(%rbp), %rdi
leaq 0x2c3a8(%rip), %rsi     # 0x67a2a
callq 0x3bdd0
testb $0x1, %al
jne 0x3b68d
jmp 0x3b699
movl $0x0, -0x14(%rbp)
jmp 0x3b763
leaq -0x10(%rbp), %rdi
leaq 0x2c38d(%rip), %rsi     # 0x67a31
callq 0x3be70
testb $0x1, %al
jne 0x3b6af
jmp 0x3b6bb
movl $0x1, -0x14(%rbp)
jmp 0x3b761
leaq -0x10(%rbp), %rdi
leaq 0x2c374(%rip), %rsi     # 0x67a3a
callq 0x3bf10
testb $0x1, %al
jne 0x3b6d1
jmp 0x3b6dd
movl $0x2, -0x14(%rbp)
jmp 0x3b75f
leaq -0x10(%rbp), %rdi
leaq 0x2c35a(%rip), %rsi     # 0x67a42
callq 0x3bf10
testb $0x1, %al
jne 0x3b6f3
jmp 0x3b6fc
movl $0x3, -0x14(%rbp)
jmp 0x3b75d
leaq -0x10(%rbp), %rdi
leaq 0x2c343(%rip), %rsi     # 0x67a4a
callq 0x3bdd0
testb $0x1, %al
jne 0x3b712
jmp 0x3b71b
movl $0x4, -0x14(%rbp)
jmp 0x3b75b
leaq -0x10(%rbp), %rdi
leaq 0x2c32b(%rip), %rsi     # 0x67a51
callq 0x3bfb0
testb $0x1, %al
jne 0x3b731
jmp 0x3b73a
movl $0x5, -0x14(%rbp)
jmp 0x3b759
leaq -0x10(%rbp), %rdi
leaq 0x2c316(%rip), %rsi     # 0x67a5b
callq 0x3bfb0
testb $0x1, %al
jne 0x3b750
jmp 0x3b757
movl $0x6, -0x14(%rbp)
jmp 0x3b759
jmp 0x3b75b
jmp 0x3b75d
jmp 0x3b75f
jmp 0x3b761
jmp 0x3b763
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jpcima[P]faustmd/metadata.cpp
// Function: Metadata::Widget::scale_from_name(gsl::basic_string_span<char const>)
Metadata::Widget::Scale Metadata::Widget::scale_from_name(gsl::cstring_span name)
{
    Metadata::Widget::Scale s = (Metadata::Widget::Scale)-1;

    if (name == "log")
        s = Scale::Log;
    else if (name == "exp")
        s = Scale::Exp;

    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
leaq -0x10(%rbp), %rdi
leaq 0x2c2d3(%rip), %rsi     # 0x67a65
callq 0x3c050
testb $0x1, %al
jne 0x3b79d
jmp 0x3b7a6
movl $0x1, -0x14(%rbp)
jmp 0x3b7c5
leaq -0x10(%rbp), %rdi
leaq 0x2c2b8(%rip), %rsi     # 0x67a69
callq 0x3c050
testb $0x1, %al
jne 0x3b7bc
jmp 0x3b7c3
movl $0x2, -0x14(%rbp)
jmp 0x3b7c5
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jpcima[P]faustmd/metadata.cpp
// Function: operator<<(std::ostream&, Metadata::Widget::Type)
std::ostream &operator<<(std::ostream &o, Metadata::Widget::Type t)
{
    switch (t) {
    case Metadata::Widget::Type::Button: return o << "button";
    case Metadata::Widget::Type::CheckBox: return o << "checkbox";
    case Metadata::Widget::Type::VSlider: return o << "vslider";
    case Metadata::Widget::Type::HSlider: return o << "hslider";
    case Metadata::Widget::Type::NEntry: return o << "nentry";
    case Metadata::Widget::Type::VBarGraph: return o << "vbargraph";
    case Metadata::Widget::Type::HBarGraph: return o << "hbargraph";
    }

    assert(false);
    return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x6, %rax
ja 0x3b8a4
movq -0x20(%rbp), %rax
leaq 0x2be49(%rip), %rcx     # 0x67644
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
leaq 0x2c21b(%rip), %rsi     # 0x67a2a
callq 0x7540
movq %rax, -0x8(%rbp)
jmp 0x3b8c3
movq -0x10(%rbp), %rdi
leaq 0x2c209(%rip), %rsi     # 0x67a31
callq 0x7540
movq %rax, -0x8(%rbp)
jmp 0x3b8c3
movq -0x10(%rbp), %rdi
leaq 0x2c1f9(%rip), %rsi     # 0x67a3a
callq 0x7540
movq %rax, -0x8(%rbp)
jmp 0x3b8c3
movq -0x10(%rbp), %rdi
leaq 0x2c1eb(%rip), %rsi     # 0x67a42
callq 0x7540
movq %rax, -0x8(%rbp)
jmp 0x3b8c3
movq -0x10(%rbp), %rdi
leaq 0x2c1dd(%rip), %rsi     # 0x67a4a
callq 0x7540
movq %rax, -0x8(%rbp)
jmp 0x3b8c3
movq -0x10(%rbp), %rdi
leaq 0x2c1ce(%rip), %rsi     # 0x67a51
callq 0x7540
movq %rax, -0x8(%rbp)
jmp 0x3b8c3
movq -0x10(%rbp), %rdi
leaq 0x2c1c2(%rip), %rsi     # 0x67a5b
callq 0x7540
movq %rax, -0x8(%rbp)
jmp 0x3b8c3
leaq 0x2c1c2(%rip), %rdi     # 0x67a6d
leaq 0x2c1c1(%rip), %rsi     # 0x67a73
movl $0x1b8, %edx            # imm = 0x1B8
leaq 0x2c1c2(%rip), %rcx     # 0x67a80
callq 0x73d0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jpcima[P]faustmd/metadata.cpp
// Function: operator<<(std::ostream&, Metadata::Widget::Scale)
std::ostream &operator<<(std::ostream &o, Metadata::Widget::Scale s)
{
    switch (s) {
    case Metadata::Widget::Scale::Linear: return o << "linear";
    case Metadata::Widget::Scale::Log: return o << "log";
    case Metadata::Widget::Scale::Exp: return o << "exp";
    }

    assert(false);
    return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x3b8ff
jmp 0x3b8eb
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x3b915
jmp 0x3b8f5
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x3b92b
jmp 0x3b941
movq -0x10(%rbp), %rdi
leaq 0x2c1b7(%rip), %rsi     # 0x67ac1
callq 0x7540
movq %rax, -0x8(%rbp)
jmp 0x3b960
movq -0x10(%rbp), %rdi
leaq 0x2c145(%rip), %rsi     # 0x67a65
callq 0x7540
movq %rax, -0x8(%rbp)
jmp 0x3b960
movq -0x10(%rbp), %rdi
leaq 0x2c133(%rip), %rsi     # 0x67a69
callq 0x7540
movq %rax, -0x8(%rbp)
jmp 0x3b960
leaq 0x2c125(%rip), %rdi     # 0x67a6d
leaq 0x2c124(%rip), %rsi     # 0x67a73
movl $0x1c4, %edx            # imm = 0x1C4
leaq 0x2c16d(%rip), %rcx     # 0x67ac8
callq 0x73d0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jpcima[P]faustmd/metadata.cpp
// Function: mangle[abi:cxx11](gsl::basic_string_span<char const>)
static const std::string mangle(gsl::cstring_span name)
{
    std::string id;
    size_t n = name.size();
    id.reserve(n);

    for (size_t i = 0; i < n; ++i) {
        char c = name[i];
        bool al = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
        bool num = c >= '0' && c <= '9';
        c = (!al && (!num || i == 0)) ? '_' : c;
        id.push_back(c);
    }

    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x77f0
leaq -0x18(%rbp), %rdi
callq 0x9360
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x78e0
jmp 0x3b9b4
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x3baa8
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x367c0
movq %rax, -0x60(%rbp)
jmp 0x3b9dd
movq -0x60(%rbp), %rax
movb (%rax), %al
movb %al, -0x41(%rbp)
movsbl -0x41(%rbp), %eax
cmpl $0x61, %eax
jl 0x3b9fd
movsbl -0x41(%rbp), %ecx
movb $0x1, %al
cmpl $0x7a, %ecx
movb %al, -0x61(%rbp)
jle 0x3ba1e
movsbl -0x41(%rbp), %ecx
xorl %eax, %eax
cmpl $0x41, %ecx
movb %al, -0x62(%rbp)
jl 0x3ba18
movsbl -0x41(%rbp), %eax
cmpl $0x5a, %eax
setle %al
movb %al, -0x62(%rbp)
movb -0x62(%rbp), %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
andb $0x1, %al
movb %al, -0x42(%rbp)
movsbl -0x41(%rbp), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x63(%rbp)
jl 0x3ba41
movsbl -0x41(%rbp), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x63(%rbp)
movb -0x63(%rbp), %al
andb $0x1, %al
movb %al, -0x43(%rbp)
testb $0x1, -0x42(%rbp)
jne 0x3ba63
testb $0x1, -0x43(%rbp)
je 0x3ba5c
cmpq $0x0, -0x40(%rbp)
jne 0x3ba63
movb $0x5f, %al
movb %al, -0x64(%rbp)
jmp 0x3ba69
movb -0x41(%rbp), %al
movb %al, -0x64(%rbp)
movq -0x50(%rbp), %rdi
movb -0x64(%rbp), %al
movb %al, -0x41(%rbp)
movsbl -0x41(%rbp), %esi
callq 0x74d0
jmp 0x3ba7e
jmp 0x3ba80
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x3b9bc
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x7380
jmp 0x3bac5
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3babb
movq -0x50(%rbp), %rdi
callq 0x7380
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x7a20
nop
// File: jpcima[P]faustmd/metadata.cpp
// Function: is_decint_string(gsl::basic_string_span<char const>)
static bool is_decint_string(gsl::cstring_span str)
{
    if (!str.empty() && str[0] == '-')
        str = str.subspan(1);

    if (str.empty())
        return false;

    for (char c : str) {
        if (c < '0' || c > '9')
            return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3c660
testb $0x1, %al
jne 0x3bb28
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x367c0
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x3bb28
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xd890
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3c660
testb $0x1, %al
jne 0x3bb37
jmp 0x3bb3d
movb $0x0, -0x1(%rbp)
jmp 0x3bb9e
leaq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x93b0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe3b0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x3bb9a
movq -0x38(%rbp), %rax
movb (%rax), %al
movb %al, -0x41(%rbp)
movsbl -0x41(%rbp), %eax
cmpl $0x30, %eax
jl 0x3bb84
movsbl -0x41(%rbp), %eax
cmpl $0x39, %eax
jle 0x3bb8a
movb $0x0, -0x1(%rbp)
jmp 0x3bb9e
jmp 0x3bb8c
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3bb5f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: t0mm4rx[P]piscine_cpp/day01/ex04/exo04.cpp
// Function: main
int main()
{
	std::string str = "HI THIS IS BRAIN";
	std::string *ptr = &str;
	std::string &ref = str;

	std::cout << "String:    " << str << std::endl;
	std::cout << "Pointer:   " << *ptr << std::endl;
	std::cout << "Reference: " << ref << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x21(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2190
movq -0x50(%rbp), %rdx
leaq 0xce1(%rip), %rsi       # 0x3004
leaq -0x20(%rbp), %rdi
callq 0x2450
jmp 0x232e
leaq -0x21(%rbp), %rdi
callq 0x2110
leaq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq 0x2c8e(%rip), %rdi      # 0x4fd8
leaq 0xcc4(%rip), %rsi       # 0x3015
callq 0x20e0
movq %rax, -0x58(%rbp)
jmp 0x235c
movq -0x58(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x20d0
movq %rax, -0x60(%rbp)
jmp 0x236f
movq -0x60(%rbp), %rdi
movq 0x2c4e(%rip), %rsi      # 0x4fc8
callq 0x20f0
jmp 0x2381
movq 0x2c50(%rip), %rdi      # 0x4fd8
leaq 0xc92(%rip), %rsi       # 0x3021
callq 0x20e0
movq %rax, -0x68(%rbp)
jmp 0x239a
movq -0x68(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x20d0
movq %rax, -0x70(%rbp)
jmp 0x23ad
movq -0x70(%rbp), %rdi
movq 0x2c10(%rip), %rsi      # 0x4fc8
callq 0x20f0
jmp 0x23bf
movq 0x2c12(%rip), %rdi      # 0x4fd8
leaq 0xc60(%rip), %rsi       # 0x302d
callq 0x20e0
movq %rax, -0x78(%rbp)
jmp 0x23d8
movq -0x78(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x20d0
movq %rax, -0x80(%rbp)
jmp 0x23eb
movq -0x80(%rbp), %rdi
movq 0x2bd2(%rip), %rsi      # 0x4fc8
callq 0x20f0
jmp 0x23fd
leaq -0x20(%rbp), %rdi
callq 0x2070
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x2110
jmp 0x243d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2070
movq -0x30(%rbp), %rdi
callq 0x2180
nopw %cs:(%rax,%rax)
// File: lns[P]team-tactic-topic-model/./lda.cpp
// Function: LDA<unsigned int, unsigned int, unsigned char>::read_data(char const*)
void read_data(const char * filename)
	{
		FILE * f = fopen(filename,"r");
		if(!f)
			printf("Cannot open %s for reading.\n",filename);
		uint32_t d;
		word_t w;
		player_t p;
		float x,y;
		while(true) {
			if(5>fscanf(f,"%u %u %u %f %f\n",&d,&w,&p,&x,&y))
				return;
			n_word = n_word>w?n_word:(w+1);
			n_player = n_player>p?n_player:(p+1);
			while(dat.size()<=d)
				dat.push_back(vector<Token>());
			dat[d].push_back({w,p,0,x,y});
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8651(%rip), %rsi      # 0xa1c7
callq 0x1140
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1b98
movq -0x10(%rbp), %rsi
leaq 0x8638(%rip), %rdi      # 0xa1c9
movb $0x0, %al
callq 0x1040
jmp 0x1b9a
movq -0x18(%rbp), %rdi
leaq 0x8641(%rip), %rsi      # 0xa1e6
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x24(%rbp), %r8
leaq -0x28(%rbp), %r9
leaq -0x2c(%rbp), %rax
movq %rax, (%rsp)
movb $0x0, %al
callq 0x11e0
movl %eax, %ecx
movl $0x5, %eax
cmpl %ecx, %eax
jle 0x1bd8
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x20(%rbp), %eax
jbe 0x1bf0
movq -0x78(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x7c(%rbp)
jmp 0x1bf9
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
movq -0x78(%rbp), %rax
movl -0x7c(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl 0x8(%rax), %eax
cmpl -0x24(%rbp), %eax
jbe 0x1c17
movq -0x78(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x80(%rbp)
jmp 0x1c20
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x80(%rbp)
movq -0x78(%rbp), %rax
movl -0x80(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x78(%rbp), %rdi
addq $0x58, %rdi
callq 0x1d00
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
ja 0x1ca4
movq -0x78(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x90(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x36b0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x3680
jmp 0x1c82
leaq -0x50(%rbp), %rdi
callq 0x30d0
jmp 0x1c2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x30d0
jmp 0x1ceb
movq -0x78(%rbp), %rdi
addq $0x58, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x36d0
movq %rax, %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x70(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x6c(%rbp)
movb $0x0, -0x68(%rbp)
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x64(%rbp)
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x60(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x36f0
jmp 0x1b9a
movq -0x58(%rbp), %rdi
callq 0x11b0
nopw %cs:(%rax,%rax)
nop