LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/allocator.c
// Function: allocator_list_search_by_sizemem
static void*allocator_list_search_by_sizemem(struct ALLOCATOR_LIST*list, size_t sizemem)
{
    void*cur = list->first;

    while (cur != NULL) {
        if (BLOCK_L_DATA_LEN(cur) >= sizemem) {
            return cur;
        }

        cur = BLOCK_LIST_NEXT(cur);
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x17104
movq -0x20(%rbp), %rax
movq 0x1(%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0x170f6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1710c
movq -0x20(%rbp), %rax
movq 0x11(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x170d7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/allocator.c
// Function: allocator_list_remove_elem
static void allocator_list_remove_elem(struct ALLOCATOR_LIST*list, void*elem)
{
    void*list_prev = BLOCK_LIST_PREV(elem);
    void*list_next = BLOCK_LIST_NEXT(elem);

    if (list_prev != NULL) {
        BLOCK_LIST_NEXT(list_prev) = list_next;
    }
    if (list_next != NULL) {
        BLOCK_LIST_PREV(list_next) = list_prev;
    }

    if (list_prev == NULL) {
        list->first = list_next;
            
    }
    if (list_next == NULL) {
        list->last = list_prev;
    }

    list->count--;
    list->sizemem -= BLOCK_L_DATA_LEN(elem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x9(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x11(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x17157
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x11(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x1716a
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x9(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x1717c
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x1718f
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x1(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/allocator.c
// Function: allocator_list_push_back
static void allocator_list_push_back(struct ALLOCATOR_LIST*list, void*elem)
{
    BLOCK_LIST_NEXT(elem) = NULL;
    BLOCK_LIST_PREV(elem) = list->last;
    
    if (list->last != NULL) {
        BLOCK_LIST_NEXT(list->last) = elem;
    }
    
    list->last = elem;
    
    if (list->first == NULL) {
        list->first = elem;
    }

    list->count++;
    list->sizemem += BLOCK_L_DATA_LEN(elem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x11(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x9(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x17203
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x11(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x17224
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x1(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/allocator.c
// Function: allocator_list_insert_elem
static void allocator_list_insert_elem(struct ALLOCATOR_LIST*list, void*elem)
{
    size_t len = BLOCK_L_DATA_LEN(elem);
    void*list_next = allocator_list_search_by_sizemem(list, len);

    if (list_next == NULL) {
        allocator_list_push_back(list, elem);
    } else {
        void*prev_elem;
        
        if (BLOCK_LIST_PREV(list_next) == NULL) {
            allocator_list_push_front(list, elem);
            return;
        }

        BLOCK_LIST_PREV(elem) = BLOCK_LIST_PREV(list_next);
        prev_elem = BLOCK_LIST_PREV(list_next);
        BLOCK_LIST_NEXT(prev_elem) = elem;
        BLOCK_LIST_NEXT(elem) = list_next;
        BLOCK_LIST_PREV(list_next) = elem;

        list->count++;
        list->sizemem += BLOCK_L_DATA_LEN(elem);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x170c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x17293
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x171c0
jmp 0x17311
movq -0x20(%rbp), %rax
cmpq $0x0, 0x9(%rax)
jne 0x172ad
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x178b0
jmp 0x17311
movq -0x20(%rbp), %rax
movq 0x9(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x9(%rax)
movq -0x20(%rbp), %rax
movq 0x9(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x11(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x11(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x9(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x1(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/masyagin1998[P]GCI/src/garbage-collector/allocator.c
// Function: allocator_list_push_front
static void allocator_list_push_front(struct ALLOCATOR_LIST*list, void*elem)
{
    BLOCK_LIST_NEXT(elem) = list->first;
    BLOCK_LIST_PREV(elem) = NULL;

    if (list->first != NULL) {
        BLOCK_LIST_PREV(list->first) = elem;
    }
    
    list->first = elem;

    if (list->last == NULL) {
        list->last = elem;
    }

    list->count++;
    list->sizemem += BLOCK_L_DATA_LEN(elem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x11(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x9(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x178f0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x9(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x17912
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x1(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_18/dcl.c
// Function: main
int main(void)
{
  while (get_next_token() != EOF)
  {
    if (next_token == '\n')
    {
      continue;
    }

    strcpy(data_type, token);
    out[0] = '\0';

    dcl();

    if (next_token != '\n')
    {
      if (next_token == NAME)
      {
        printf("Syntax Error: '%s' unexpected.\n", token);
      }
      else
      {
        printf("Syntax Error: '%c' unexpected.\n", next_token);
      }

      do
      {
        get_next_token();
      } while (next_token != '\n' && next_token != EOF);
    }
    else
    {
      printf("%s:%s %s\n", name, out, data_type);
    }
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1280
cmpl $-0x1, %eax
je 0x1277
cmpl $0xa, 0x2eac(%rip)      # 0x4070
jne 0x11c8
jmp 0x11af
leaq 0x2eb1(%rip), %rdi      # 0x4080
leaq 0x2f1a(%rip), %rsi      # 0x40f0
callq 0x1030
movb $0x0, 0x2f7e(%rip)      # 0x4160
callq 0x1400
cmpl $0xa, 0x2e82(%rip)      # 0x4070
je 0x124f
cmpl $0x0, 0x2e79(%rip)      # 0x4070
jne 0x1210
leaq 0xe04(%rip), %rdi       # 0x2004
leaq 0x2ee9(%rip), %rsi      # 0x40f0
movb $0x0, %al
callq 0x1050
jmp 0x1224
movl 0x2e5a(%rip), %esi      # 0x4070
leaq 0xe07(%rip), %rdi       # 0x2024
movb $0x0, %al
callq 0x1050
jmp 0x1226
callq 0x1280
xorl %eax, %eax
cmpl $0xa, 0x2e3c(%rip)      # 0x4070
movb %al, -0x5(%rbp)
je 0x1246
cmpl $-0x1, 0x2e30(%rip)     # 0x4070
setne %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x1226
jmp 0x1272
leaq 0xdee(%rip), %rdi       # 0x2044
leaq 0x32f3(%rip), %rsi      # 0x4550
leaq 0x2efc(%rip), %rdx      # 0x4160
leaq 0x2e15(%rip), %rcx      # 0x4080
movb $0x0, %al
callq 0x1050
jmp 0x11af
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_18/dcl.c
// Function: dir_dcl
void dir_dcl(void)
{
  if (next_token == PAREN_OPEN)
  {
    dcl();

    if (next_token != PAREN_CLOSE)
    {
      puts("Syntax Error: missing ')'.");
    }
  }
  else if (next_token == NAME)
  {
    strcpy(name, token);
  }
  else
  {
    puts("Syntax Error: expected name or (dcl).");
  }

  while ((next_token = get_next_token()) == PARENS || next_token == BRACKETS)
  {
    if (next_token == PARENS)
    {
      strcat(out, " function returning");
    }
    else if (next_token == BRACKETS)
    {
      strcat(out, " array[");
      strcat(out, token);
      strcat(out, "] of");
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x28, 0x29f1(%rip)     # 0x4070
jne 0x169d
callq 0x1400
cmpl $0x29, 0x29e3(%rip)     # 0x4070
je 0x169b
leaq 0x9c7(%rip), %rdi       # 0x205d
callq 0x1040
jmp 0x16c9
cmpl $0x0, 0x29cc(%rip)      # 0x4070
jne 0x16bb
leaq 0x2ea3(%rip), %rdi      # 0x4550
leaq 0x2a3c(%rip), %rsi      # 0x40f0
callq 0x1030
jmp 0x16c7
leaq 0x9b6(%rip), %rdi       # 0x2078
callq 0x1040
jmp 0x16c9
jmp 0x16cb
callq 0x1280
movl %eax, %ecx
movl %ecx, 0x2998(%rip)      # 0x4070
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, -0x1(%rbp)
je 0x16ef
cmpl $0x2, 0x2987(%rip)      # 0x4070
sete %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x16f8
jmp 0x175f
cmpl $0x1, 0x2971(%rip)      # 0x4070
jne 0x1716
leaq 0x2a58(%rip), %rdi      # 0x4160
leaq 0x98f(%rip), %rsi       # 0x209e
callq 0x1070
jmp 0x175a
cmpl $0x2, 0x2953(%rip)      # 0x4070
jne 0x1758
leaq 0x2a3a(%rip), %rdi      # 0x4160
leaq 0x985(%rip), %rsi       # 0x20b2
callq 0x1070
leaq 0x2a27(%rip), %rdi      # 0x4160
leaq 0x29b0(%rip), %rsi      # 0x40f0
callq 0x1070
leaq 0x2a14(%rip), %rdi      # 0x4160
leaq 0x967(%rip), %rsi       # 0x20ba
callq 0x1070
jmp 0x175a
jmp 0x16cb
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/decimal.c
// Function: factorial
struct tt_dec *factorial(int i, int j)
{
	struct tt_dec *dec;

	if (i == j) {
		dec = tt_dec_alloc(0);
		tt_dec_from_uint(dec, i);
		return dec;
	}

	int m = (i + j) / 2;
	struct tt_dec *dec1 = factorial(i, m);
	struct tt_dec *dec2 = factorial(m+1, j);

	dec = tt_dec_alloc(dec1->_prec + dec2->_prec);
	tt_dec_mul(dec, dec1, dec2);

	tt_dec_free(dec1);
	tt_dec_free(dec2);

	return dec;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movl %esi, 0x28(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jne 0x2340
xorl %edi, %edi
callq 0x4660
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x4d10
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x23c7
movl 0x2c(%rsp), %eax
addl 0x28(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x1c(%rsp)
movl 0x2c(%rsp), %edi
movl 0x1c(%rsp), %esi
callq 0x2300
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %edi
addl $0x1, %edi
movl 0x28(%rsp), %esi
callq 0x2300
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edi
movq 0x8(%rsp), %rax
addl 0x8(%rax), %edi
callq 0x4660
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x6b80
movq 0x10(%rsp), %rdi
callq 0x47e0
movq 0x8(%rsp), %rdi
callq 0x47e0
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/decimal.c
// Function: get_num
static long double get_num(char *s, int lmin, int lmax)
{
	long double ld = 0;

	s[0] = ((rand() & 1)) ? '-' : '+';

	/* len: lmin+1 ~ lmax+1 */
	int len = lmin + rand() % (lmax - lmin + 1) + 1;
	for (int i = 1; i < len; i++) {
		s[i] = rand() % 10;
		ld *= 10;
		ld += s[i];
		s[i] += '0';
	}
	s[len] = '\0';

	if (s[0] == '-')
		ld = -ld;

	return ld;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
fldz
fstpt 0x10(%rsp)
callq 0x21f0
movl %eax, %edx
andl $0x1, %edx
movl $0x2b, %eax
movl $0x2d, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq 0x30(%rsp), %rax
movb %cl, (%rax)
movl 0x2c(%rsp), %eax
movl %eax, (%rsp)
callq 0x21f0
movl 0x28(%rsp), %ecx
subl 0x2c(%rsp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl (%rsp), %eax
addl %edx, %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl $0x1, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x432e
callq 0x21f0
movslq %eax, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rcx
shrq $0x3f, %rcx
shrq $0x22, %rdx
addl %ecx, %edx
addl %edx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movb %al, %dl
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
fldt 0x10(%rsp)
flds 0x10d54(%rip)           # 0x15038
fmulp %st, %st(1)
fstpt 0x10(%rsp)
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, 0x4(%rsp)
fildl 0x4(%rsp)
fldt 0x10(%rsp)
faddp %st, %st(1)
fstpt 0x10(%rsp)
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %edx
addl $0x30, %edx
movb %dl, (%rax,%rcx)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4298
movq 0x30(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x30(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x4353
fldt 0x10(%rsp)
fchs
fstpt 0x10(%rsp)
fldt 0x10(%rsp)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/decimal.c
// Function: deq
static bool deq(double d1, double d2, double prec)
{
	if (isnan(d1))
		return isnan(d2);
	if (isinf(d1))
		return isinf(d2) && signbit(d1) == signbit(d2);
	if (d1 == 0)
		return d2 == 0;
	long double dd = (long double)d1 - (long double)d2;
	dd /= d1;
	return dd < prec;
}

// Assembly:
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd %xmm2, -0x20(%rsp)
movsd -0x10(%rsp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x4385
jmp 0x439d
movsd -0x18(%rsp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x44de
movsd -0x10(%rsp), %xmm1
movaps %xmm1, %xmm0
movaps 0x10c93(%rip), %xmm2    # 0x15040
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x10c49(%rip), %xmm1    # 0x15018
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x447f
movsd -0x18(%rsp), %xmm1
movaps %xmm1, %xmm0
movaps 0x10c45(%rip), %xmm2    # 0x15040
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %ecx, %eax
movsd 0x10bfb(%rip), %xmm1    # 0x15018
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rsp)
je 0x4473
movsd -0x10(%rsp), %xmm0
movq %xmm0, %rax
cmpq $0x0, %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
movsd -0x18(%rsp), %xmm0
movq %xmm0, %rcx
cmpq $0x0, %rcx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x39(%rsp)
movb -0x39(%rsp), %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x44de
movsd -0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x44ad
jp 0x44ad
movsd -0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x44de
fldl -0x10(%rsp)
fldl -0x18(%rsp)
fsubrp %st, %st(1)
fstpt -0x38(%rsp)
fldl -0x10(%rsp)
fldt -0x38(%rsp)
fdivp %st, %st(1)
fstpt -0x38(%rsp)
fldt -0x38(%rsp)
fldl -0x20(%rsp)
fucompi %st(1), %st
fstp %st(0)
seta %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/decimal.c
// Function: gen_float
static double gen_float(int mexp)
{
	union {
		uint64_t i;
		double d;
	} v = {
		.i = 0,
	};

	/* Sign: 0,1 */
	if (rand() & 1)
		v.i |= 1ULL << 63;

	/* Exponent: -mexp ~ +mexp */
	double _exp = (double)(rand() % (mexp + 1));	/* 0 ~ mexp */
	if (rand() & 1)
		_exp = -_exp;
	int e = 1023;
	if (_exp > 0)
		e = (int)(_exp / log10(2) + 1023);
	else if (_exp < 0)
		e = (int)(_exp / log10(2) + 1024);
	v.i |= ((int64_t)e) << 52;

	/* Mantissa */
	int64_t i64 = rand();
	i64 *= rand();
	v.i |= (i64 & ((1ULL << 52) - 1));

	return v.d;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x20e0
callq 0x21f0
andl $0x1, %eax
cmpl $0x0, %eax
je 0x452a
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
orq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x21f0
movl 0x34(%rsp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
cvtsi2sd %edx, %xmm0
movsd %xmm0, 0x20(%rsp)
callq 0x21f0
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4573
movsd 0x20(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x3ff, 0x1c(%rsp)      # imm = 0x3FF
movsd 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x45c6
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10a8a(%rip), %xmm0    # 0x15028
callq 0x2130
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd 0x10a78(%rip), %xmm1    # 0x15030
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%rsp)
jmp 0x460b
xorps %xmm0, %xmm0
ucomisd 0x20(%rsp), %xmm0
jbe 0x4609
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10a44(%rip), %xmm0    # 0x15028
callq 0x2130
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
movsd 0x10a23(%rip), %xmm1    # 0x15020
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%rsp)
jmp 0x460b
movslq 0x1c(%rsp), %rax
shlq $0x34, %rax
orq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x21f0
cltq
movq %rax, 0x10(%rsp)
callq 0x21f0
cltq
imulq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
andq 0x10(%rsp), %rax
orq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/test.c
// Function: test_digest_case
static int
test_digest_case(const struct libkeccak_spec *restrict spec, const char *restrict suffix,
                 const char *restrict msg, size_t bytes, size_t bits, const char *restrict expected_answer)
{
	struct libkeccak_state state;
	int ret;
	if (libkeccak_state_initialise(&state, spec)) {
		perror("libkeccak_state_initialise");
		return -1;
	}
	ret = test_digest_case_inited(&state, spec, suffix, msg, bytes, bits, expected_answer);
	libkeccak_state_fast_destroy(&state);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x158(%rbp), %rdi
callq 0xafd0
cmpl $0x0, %eax
je 0x4d9d
leaq 0x8494(%rip), %rdi      # 0xd223
callq 0x1100
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4de0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rax
leaq -0x158(%rbp), %rdi
movq %rax, (%rsp)
callq 0x4df0
movl %eax, -0x15c(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xaf90
movl -0x15c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/test.c
// Function: test_digest_case_cshake
static int
test_digest_case_cshake(const struct libkeccak_spec *restrict spec, const char *restrict suffix,
                        const void *n_text, size_t n_len, size_t n_bits, const char *n_suffix,
                        const void *s_text, size_t s_len, size_t s_bits, const char *s_suffix,
                        const char *restrict msg, size_t bytes, size_t bits, const char *restrict expected_answer)
{
	struct libkeccak_state state;
	int ret;
	if (libkeccak_state_initialise(&state, spec)) {
		perror("libkeccak_state_initialise");
		return -1;
	}
	libkeccak_cshake_initialise(&state, n_text, n_len, n_bits, n_suffix, s_text, s_len, s_bits, s_suffix);
	ret = test_digest_case_inited(&state, spec, suffix, msg, bytes, bits, expected_answer);
	libkeccak_state_fast_destroy(&state);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq 0x48(%rbp), %rax
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x158(%rbp), %rdi
callq 0xafd0
cmpl $0x0, %eax
je 0x502d
leaq 0x8204(%rip), %rdi      # 0xd223
callq 0x1100
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x50aa
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq 0x10(%rbp), %r9
movq 0x18(%rbp), %r11
movq 0x20(%rbp), %r10
movq 0x28(%rbp), %rax
leaq -0x158(%rbp), %rdi
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0xa520
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq 0x30(%rbp), %rcx
movq 0x38(%rbp), %r8
movq 0x40(%rbp), %r9
movq 0x48(%rbp), %rax
leaq -0x158(%rbp), %rdi
movq %rax, (%rsp)
callq 0x4df0
movl %eax, -0x15c(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xaf90
movl -0x15c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/libkeccak_cshake_initialise.c
// Function: encode_left
static size_t
encode_left(struct libkeccak_state *restrict state, uint8_t *restrict buf, size_t byterate, size_t value, size_t off)
{
	size_t x, n, j, i = off;

	for (x = value, n = 0; x; x >>= 8)
		n += 1;
	if (!n)
		n = 1;
	buf[i++] = (uint8_t)n;
	if (i == byterate) {
		libkeccak_zerocopy_update(state, buf, byterate);
		i = 0;
	}

	for (j = 0; j < n;) {
		buf[i++] = (uint8_t)(value >> ((n - ++j) << 3));
		if (i == byterate) {
			libkeccak_zerocopy_update(state, buf, byterate);
			i = 0;
		}
	}

	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa8d5
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0xa8b4
cmpq $0x0, -0x38(%rbp)
jne 0xa8e4
movq $0x1, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x48(%rbp)
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xa923
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x54e0
movq $0x0, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xa990
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rdx
addq $0x1, %rdx
movq %rdx, -0x40(%rbp)
subq %rdx, %rcx
shlq $0x3, %rcx
shrq %cl, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x48(%rbp)
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xa98e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x54e0
movq $0x0, -0x48(%rbp)
jmp 0xa92b
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/libkeccak_cshake_initialise.c
// Function: encode_left_shifted
static size_t
encode_left_shifted(struct libkeccak_state *restrict state, uint8_t *restrict buf,
                    size_t byterate, size_t value, size_t off, size_t bitoff)
{
	size_t x, n, j, i = off;
	uint16_t v;

	for (x = value, n = 0; x; x >>= 8)
		n += 1;
	if (!n)
		n = 1;
	v = (uint16_t)((n & 255UL) << bitoff);
	buf[i++] |= (uint8_t)v;
	if (i == byterate) {
		libkeccak_zerocopy_update(state, buf, byterate);
		i = 0;
	}
	buf[i] = (uint8_t)(n >> 8);

	for (j = 0; j < n;) {
		v = (uint16_t)(((value >> ((n - ++j) << 3)) & 255UL) << bitoff);
		buf[i++] |= (uint8_t)v;
		if (i == byterate) {
			libkeccak_zerocopy_update(state, buf, byterate);
			i = 0;
		}
		buf[i] = (uint8_t)(v >> 8);
	}

	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xac19
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0xabf8
cmpq $0x0, -0x40(%rbp)
jne 0xac28
movq $0x1, -0x40(%rbp)
movq -0x40(%rbp), %rax
andq $0xff, %rax
movq -0x30(%rbp), %rcx
shlq %cl, %rax
movw %ax, -0x52(%rbp)
movw -0x52(%rbp), %ax
movzbl %al, %esi
movq -0x10(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xac83
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x54e0
movq $0x0, -0x50(%rbp)
movq -0x40(%rbp), %rax
shrq $0x8, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x50(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xad3c
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rdx
addq $0x1, %rdx
movq %rdx, -0x48(%rbp)
subq %rdx, %rcx
shlq $0x3, %rcx
shrq %cl, %rax
andq $0xff, %rax
movq -0x30(%rbp), %rcx
shlq %cl, %rax
movw %ax, -0x52(%rbp)
movw -0x52(%rbp), %ax
movzbl %al, %esi
movq -0x10(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x50(%rbp)
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xad23
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x54e0
movq $0x0, -0x50(%rbp)
movzwl -0x52(%rbp), %eax
sarl $0x8, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x50(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xaca0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/extra/libkeccak_state_create.c
// Function: libkeccak_state_create
struct libkeccak_state *
libkeccak_state_create(const struct libkeccak_spec *spec)
{
	struct libkeccak_state *state = malloc(sizeof(struct libkeccak_state));
	if (!state || libkeccak_state_initialise(state, spec)) {
		free(state);
		return NULL;
	}
	return state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x120, %edi            # imm = 0x120
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb233
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xafd0
cmpl $0x0, %eax
je 0xb246
movq -0x18(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0xb24e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/extra/libkeccak_state_duplicate.c
// Function: libkeccak_state_duplicate
struct libkeccak_state *
libkeccak_state_duplicate(const struct libkeccak_state *src)
{
	struct libkeccak_state *dest = malloc(sizeof(struct libkeccak_state));
	if (!dest || libkeccak_state_copy(dest, src)) {
		libkeccak_state_free(dest);
		return NULL;
	}
	return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x120, %edi            # imm = 0x120
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb293
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc3b0
cmpl $0x0, %eax
je 0xb2a6
movq -0x18(%rbp), %rdi
callq 0xb2c0
movq $0x0, -0x8(%rbp)
jmp 0xb2ae
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/extra/../libkeccak/extra.h
// Function: libkeccak_state_free
inline void
libkeccak_state_free(volatile struct libkeccak_state *state)
{
#ifdef __GNUC__
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wcast-qual"
#endif
	if (state) {
		libkeccak_state_wipe(state);
		free(state->M);
		state->M = NULL;
		free((struct libkeccak_state *)state);
	}
#ifdef __GNUC__
# pragma GCC diagnostic pop
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb304
movq -0x8(%rbp), %rdi
callq 0xb7d0
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x118(%rax)
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/extra/libkeccak_state_wipe_sponge.c
// Function: libkeccak_state_wipe_sponge
void
libkeccak_state_wipe_sponge(volatile struct libkeccak_state *state)
{
	volatile uint64_t *restrict S = state->S.w64;
	size_t i;

	for (i = 0; i < 25; i++)
		S[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x19, -0x18(%rbp)
jae 0xb88d
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb868
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/spec/../libkeccak/keccak.h
// Function: libkeccak_generalised_spec_initialise
inline void
libkeccak_generalised_spec_initialise(struct libkeccak_generalised_spec *spec)
{
	spec->bitrate    = LIBKECCAK_GENERALISED_SPEC_AUTOMATIC;
	spec->capacity   = LIBKECCAK_GENERALISED_SPEC_AUTOMATIC;
	spec->output     = LIBKECCAK_GENERALISED_SPEC_AUTOMATIC;
	spec->state_size = LIBKECCAK_GENERALISED_SPEC_AUTOMATIC;
	spec->word_size  = LIBKECCAK_GENERALISED_SPEC_AUTOMATIC;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $-0x10000, (%rax)       # imm = 0xFFFF0000
movq -0x8(%rbp), %rax
movq $-0x10000, 0x8(%rax)    # imm = 0xFFFF0000
movq -0x8(%rbp), %rax
movq $-0x10000, 0x10(%rax)   # imm = 0xFFFF0000
movq -0x8(%rbp), %rax
movq $-0x10000, 0x18(%rax)   # imm = 0xFFFF0000
movq -0x8(%rbp), %rax
movq $-0x10000, 0x20(%rax)   # imm = 0xFFFF0000
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/util/libkeccak_behex_upper.c
// Function: libkeccak_behex_upper
void
libkeccak_behex_upper(char *restrict output, const void *restrict hashsum_, size_t n)
{
	const unsigned char *restrict hashsum = hashsum_;

	output[2 * n] = '\0';
	while (n--) {
		output[2 * n + 0] = "0123456789ABCDEF"[(hashsum[n] >> 4) & 15];
		output[2 * n + 1] = "0123456789ABCDEF"[(hashsum[n] >> 0) & 15];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0xbf69
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
sarl $0x4, %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x858b(%rip), %rax      # 0x144b3
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
sarl $0x0, %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x855e(%rip), %rax      # 0x144b3
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq %rcx
movb %dl, 0x1(%rax,%rcx)
jmp 0xbef7
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/util/libkeccak_unhex.c
// Function: libkeccak_unhex
void
libkeccak_unhex(void *restrict output_, const char *restrict hashsum)
{
	unsigned char *restrict output = output_;
	size_t n = strlen(hashsum) / 2;
	unsigned char a, b;

	while (n--) {
		a = (unsigned char)hashsum[2 * n + 0];
		b = (unsigned char)hashsum[2 * n + 1];

		a = (unsigned char)((a & 15) + (a > '9' ? 9 : 0));
		b = (unsigned char)((b & 15) + (b > '9' ? 9 : 0));

		a = (unsigned char)(a << 4);
		a |= b;
		output[n] = a;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1050
shrq %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
je 0xc388
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq %rcx
movb 0x1(%rax,%rcx), %al
movb %al, -0x22(%rbp)
movzbl -0x21(%rbp), %eax
andl $0xf, %eax
movzbl -0x21(%rbp), %esi
xorl %ecx, %ecx
movl $0x9, %edx
cmpl $0x39, %esi
cmovgl %edx, %ecx
addl %ecx, %eax
movb %al, -0x21(%rbp)
movzbl -0x22(%rbp), %eax
andl $0xf, %eax
movzbl -0x22(%rbp), %esi
xorl %ecx, %ecx
movl $0x9, %edx
cmpl $0x39, %esi
cmovgl %edx, %ecx
addl %ecx, %eax
movb %al, -0x22(%rbp)
movzbl -0x21(%rbp), %eax
shll $0x4, %eax
movb %al, -0x21(%rbp)
movzbl -0x22(%rbp), %ecx
movzbl -0x21(%rbp), %eax
orl %ecx, %eax
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %dl
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xc2e8
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/extra/libkeccak_state_copy.c
// Function: libkeccak_state_copy
int
libkeccak_state_copy(struct libkeccak_state *restrict dest, const struct libkeccak_state *restrict src)
{
	*dest = *src;
	if (src->mlen) {
		dest->M = malloc(src->mlen * sizeof(char));
		if (!dest->M)
			return -1;
		memcpy(dest->M, src->M, src->mptr * sizeof(char));
	} else {
		dest->M = NULL;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x120, %edx            # imm = 0x120
callq 0x10b0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x110(%rax)
je 0xc445
movq -0x18(%rbp), %rax
movq 0x110(%rax), %rdi
shlq $0x0, %rdi
callq 0x10c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x118(%rax)
jne 0xc419
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc45b
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x118(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rdx
shlq $0x0, %rdx
callq 0x10b0
jmp 0xc454
movq -0x10(%rbp), %rax
movq $0x0, 0x118(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkshapeargs.C
// Function: main
int main(int argc, char** argv) {
  int sampleRate = atoi(argv[1]);
  int baudRate = atoi(argv[2]);
  float beta = atof(argv[3]);

  float alpha = 1.0f / ((float)sampleRate / ((float)baudRate / 2.0f));

  int length = (sampleRate / baudRate * 2 + 1) * 2 - 1;

  printf("%18.10e %18.10e %d\n", alpha, beta, length);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1050
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1050
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1040
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
cvtsi2ssl 0x14(%rsp), %xmm1
cvtsi2ssl 0x10(%rsp), %xmm0
movss 0xe43(%rip), %xmm2      # 0x2008
divss %xmm2, %xmm0
divss %xmm0, %xmm1
movss 0xe2f(%rip), %xmm0      # 0x2004
divss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
movl 0x14(%rsp), %eax
cltd
idivl 0x10(%rsp)
shll %eax
addl $0x1, %eax
shll %eax
subl $0x1, %eax
movl %eax, 0x4(%rsp)
movss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movss 0xc(%rsp), %xmm1
cvtss2sd %xmm1, %xmm1
movl 0x4(%rsp), %esi
leaq 0xdf7(%rip), %rdi       # 0x200c
movb $0x2, %al
callq 0x1030
xorl %eax, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/pid_ptr.c
// Function: main
int main() {
  libforks_ServerConn conn;

  check(pipe(pipe_fds) == 0);

  check(libforks_start(&conn) == libforks_OK);

  pid_t child_pid;

  check(libforks_fork(
    conn,
    &child_pid, // pid_ptr
    NULL, // socket_fd_ptr
    NULL, // exit_fd_ptr
    child_main
  ) == libforks_OK);

  pid_t received_child_pid;
  check(
    read(
      pipe_fds[0],
      &received_child_pid, sizeof received_child_pid
    ) == sizeof received_child_pid
  ); // blocks until the child writes
  check(child_pid == received_child_pid);

  check(libforks_stop(conn) == libforks_OK);

  check(child_pid == received_child_pid);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x5dfe(%rip), %rdi      # 0x7114
callq 0x10f0
cmpl $0x0, %eax
jne 0x1322
jmp 0x133a
leaq 0x2cdb(%rip), %rdi      # 0x4004
leaq 0x2ce8(%rip), %rsi      # 0x4018
movl $0x11, %edx
callq 0x1450
leaq -0x10(%rbp), %rdi
callq 0x1b40
cmpl $0x0, %eax
jne 0x134a
jmp 0x1362
leaq 0x2cd7(%rip), %rdi      # 0x4028
leaq 0x2cc0(%rip), %rsi      # 0x4018
movl $0x13, %edx
callq 0x1450
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x11b(%rip), %r8        # 0x1490
movq %rcx, %rdx
callq 0x2310
cmpl $0x0, %eax
jne 0x1384
jmp 0x139c
leaq 0x2cc2(%rip), %rdi      # 0x404d
leaq 0x2c86(%rip), %rsi      # 0x4018
movl $0x1d, %edx
callq 0x1450
movl 0x5d72(%rip), %edi      # 0x7114
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x1100
cmpq $0x4, %rax
jne 0x13b8
jmp 0x13d0
leaq 0x2cd7(%rip), %rdi      # 0x4096
leaq 0x2c52(%rip), %rsi      # 0x4018
movl $0x25, %edx
callq 0x1450
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x13da
jmp 0x13f2
leaq 0x2d16(%rip), %rdi      # 0x40f7
leaq 0x2c30(%rip), %rsi      # 0x4018
movl $0x26, %edx
callq 0x1450
movq -0x10(%rbp), %rdi
callq 0x25a0
cmpl $0x0, %eax
jne 0x1402
jmp 0x141a
leaq 0x2d0e(%rip), %rdi      # 0x4117
leaq 0x2c08(%rip), %rsi      # 0x4018
movl $0x28, %edx
callq 0x1450
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x1424
jmp 0x143c
leaq 0x2ccc(%rip), %rdi      # 0x40f7
leaq 0x2be6(%rip), %rsi      # 0x4018
movl $0x2a, %edx
callq 0x1450
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/pid_ptr.c
// Function: child_main
static void child_main(libforks_ServerConn conn, int socket_fd) {
  (void)socket_fd;

  check(libforks_free_conn(conn) == libforks_OK);
  check(close(pipe_fds[0]) == 0);
  pid_t pid = getpid();
  check(write(pipe_fds[1], (void*)&pid, sizeof pid) == sizeof pid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2610
cmpl $0x0, %eax
jne 0x14af
jmp 0x14c7
leaq 0x2ca0(%rip), %rdi      # 0x4156
leaq 0x2b5b(%rip), %rsi      # 0x4018
movl $0x8, %edx
callq 0x1450
movl 0x5c47(%rip), %edi      # 0x7114
callq 0x10d0
cmpl $0x0, %eax
jne 0x14d9
jmp 0x14f1
leaq 0x2c9e(%rip), %rdi      # 0x417e
leaq 0x2b31(%rip), %rsi      # 0x4018
movl $0x9, %edx
callq 0x1450
callq 0x1090
movl %eax, -0x10(%rbp)
movl 0x5c19(%rip), %edi      # 0x7118
leaq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x1080
cmpq $0x4, %rax
jne 0x1515
jmp 0x152d
leaq 0x2c7a(%rip), %rdi      # 0x4196
leaq 0x2af5(%rip), %rsi      # 0x4018
movl $0xb, %edx
callq 0x1450
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/read4.c
// Function: testcase_prepare
void testcase_prepare(unsigned long nr_tasks)
{
	int fd = mkstemp(tmpfile);
	char buf[FILESIZE];

	memset(buf, 0, sizeof(buf));
	assert(fd >= 0);
	assert(write(fd, buf, sizeof(buf)) == sizeof(buf));
	close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100010, %rsp         # imm = 0x100010
movq %rdi, -0x8(%rbp)
leaq 0x31aa(%rip), %rdi      # 0x61b0
callq 0x21e0
movl %eax, -0xc(%rbp)
leaq -0x100010(%rbp), %rdi
xorl %esi, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x2130
cmpl $0x0, -0xc(%rbp)
jl 0x3029
jmp 0x3048
leaq 0x1250(%rip), %rdi      # 0x4280
leaq 0x1251(%rip), %rsi      # 0x4288
movl $0x15, %edx
leaq 0x1253(%rip), %rcx      # 0x4296
callq 0x2120
movl -0xc(%rbp), %edi
leaq -0x100010(%rbp), %rsi
movl $0x100000, %edx         # imm = 0x100000
callq 0x20c0
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x3066
jmp 0x3085
leaq 0x124e(%rip), %rdi      # 0x42bb
leaq 0x1214(%rip), %rsi      # 0x4288
movl $0x16, %edx
leaq 0x1216(%rip), %rcx      # 0x4296
callq 0x2120
movl -0xc(%rbp), %edi
callq 0x2140
addq $0x100010, %rsp         # imm = 0x100010
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/read4.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	int fd = open(tmpfile, O_DIRECT|O_RDONLY);
	char *p;

	p = aligned_alloc(getpagesize(), BUFLEN);

	while (1) {
		int ret = read(fd, p, BUFLEN);
		assert(ret >= 0);
		if (ret == 0)
			lseek(fd, 0, SEEK_SET);

		(*iterations)++;
	}
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x30f9(%rip), %rdi      # 0x61b0
movl $0x4000, %esi           # imm = 0x4000
movb $0x0, %al
callq 0x2220
movl %eax, -0x14(%rbp)
callq 0x2290
cltq
movq %rax, -0x30(%rbp)
callq 0x2290
movq -0x30(%rbp), %rdi
movslq %eax, %rsi
callq 0x22b0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x2290
movl -0x3c(%rbp), %edi
movq -0x38(%rbp), %rsi
movslq %eax, %rdx
callq 0x2160
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x3113
jmp 0x3132
leaq 0x11cc(%rip), %rdi      # 0x42e6
leaq 0x1167(%rip), %rsi      # 0x4288
movl $0x23, %edx
leaq 0x11c2(%rip), %rcx      # 0x42ef
callq 0x2120
cmpl $0x0, -0x24(%rbp)
jne 0x3146
movl -0x14(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x30e6
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch5/lua_error.c
// Function: main
int main() {

  lua_State *L = luaL_newstate();
  luaL_openlibs(L);
  lua_register(L, "fn", fn);
  
  // Call fn().
  lua_getglobal(L, "fn");
  lua_call(L, 0, 0);

  printf("Done!\n");

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x21340
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21700
movq -0x10(%rbp), %rdi
leaq -0x5c(%rip), %rsi       # 0x55e0
xorl %edx, %edx
callq 0x6a30
movq -0x10(%rbp), %rdi
leaq 0x2d9c8(%rip), %rsi     # 0x33016
callq 0x7370
movq -0x10(%rbp), %rdi
leaq 0x2d9b8(%rip), %rsi     # 0x33016
callq 0x6c40
movq -0x10(%rbp), %rdi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %r8d
movl %edx, %esi
movq %r8, %rcx
callq 0x7cd0
leaq 0x2d99a(%rip), %rdi     # 0x33019
movb $0x0, %al
callq 0x5170
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/5-Signal/infinite_loop.c
// Function: main
int main(void) {
	unsigned int i = 0;

	signal(SIGINT, sig_handler);
	printf("PID %d\n", getpid());

	while(!stop) {
		sleep(1);
		printf("%d sec\n", ++i);
		fflush(stdout);
	}

	printf("Exit peacefully\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x2, %edi
leaq -0x42(%rip), %rsi       # 0x1180
callq 0x1050
callq 0x1030
movl %eax, %esi
leaq 0xe2f(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
cmpl $0x0, 0x2e71(%rip)      # 0x4054
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11ee
jmp 0x1220
movl $0x1, %edi
callq 0x1070
movl -0x8(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x8(%rbp)
leaq 0xe04(%rip), %rdi       # 0x200c
movb $0x0, %al
callq 0x1040
movq 0x2dca(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1060
jmp 0x11dc
leaq 0xded(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch1/runmodule.c
// Function: main
int main() {

  // Create a Lua state and load the module.
  lua_State *L = luaL_newstate();
  luaL_openlibs(L);
  luaL_dofile(L, "eatyguy0.lua");
  lua_setglobal(L, "eatyguy");
  lua_settop(L, 0);

  // Run the init() function.
  lua_getglobal(L, "eatyguy");
  lua_getfield(L, -1, "init");  // -1 means stack top.
  lua_call(L, 0, 0);            // 0, 0 = #args, #retvals

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
callq 0x21350
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21710
movq -0x10(%rbp), %rdi
leaq 0x2da08(%rip), %rsi     # 0x33004
xorl %eax, %eax
movl %eax, %edx
callq 0x20820
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x5634
movq -0x10(%rbp), %rdi
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %esi
movq %r9, %r8
callq 0x7db0
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movq -0x10(%rbp), %rdi
leaq 0x2d9cf(%rip), %rsi     # 0x33011
callq 0x7380
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5960
movq -0x10(%rbp), %rdi
leaq 0x2d9b4(%rip), %rsi     # 0x33011
callq 0x6c50
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2d9a7(%rip), %rdx     # 0x33019
callq 0x6e90
movq -0x10(%rbp), %rdi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %r8d
movl %edx, %esi
movq %r8, %rcx
callq 0x7ce0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/msender.c
// Function: csum
unsigned short
csum (unsigned short *buf, int nwords)
{
    unsigned long sum;
    for (sum = 0; nwords > 0; nwords--)
        sum += *buf++;
    sum = (sum >> 16) + (sum & 0xffff);
    sum += (sum >> 16);

    return (unsigned short)~sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x124e
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x8(%rbp)
movzwl (%rax), %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1223
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movq -0x18(%rbp), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
xorq $-0x1, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)