LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/tests/test_merge.c
// Function: cmp_int
int
cmp_int(const void *first, const void *second)
{
    int a = *(int *) first;
    int b = *(int *) second;

    if (a < b)
        return -1;
    if (a > b)
        return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x16bf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16d7
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x16d0
movl $0x1, -0x4(%rbp)
jmp 0x16d7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/tests/test_merge.c
// Function: merge_suite
SUITE(merge_suite)
{
    int i;
    int c;

    for (i = 0; i < TEST_NUM; i++) {
        c = (rand() % ARR_SZ);
        if ((c < 0) || (c > ARR_SZ))
            continue;
        RUN_TEST1(do_merge_test, c);
    }

    RUN_TEST1(do_merge_test, 0);
    RUN_TEST1(do_merge_test, ARR_SZ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x80, -0x4(%rbp)
jge 0x175b
callq 0x1170
movl $0x78fb, %ecx           # imm = 0x78FB
cltd
idivl %ecx
movl %edx, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x1717
cmpl $0x78fb, -0x8(%rbp)     # imm = 0x78FB
jle 0x1719
jmp 0x1750
jmp 0x171b
leaq 0x2b11(%rip), %rdi      # 0x4233
callq 0x17d0
cmpl $0x1, %eax
jne 0x174c
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1744
movl -0x8(%rbp), %edi
callq 0x19e0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x1cb0
jmp 0x174e
jmp 0x1750
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x16ef
jmp 0x175d
leaq 0x2acf(%rip), %rdi      # 0x4233
callq 0x17d0
cmpl $0x1, %eax
jne 0x178d
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x1785
xorl %edi, %edi
callq 0x19e0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
callq 0x1cb0
jmp 0x178f
jmp 0x1791
leaq 0x2a9b(%rip), %rdi      # 0x4233
callq 0x17d0
cmpl $0x1, %eax
jne 0x17c4
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x17bc
movl $0x78fb, %edi           # imm = 0x78FB
callq 0x19e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x1cb0
jmp 0x17c6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/tests/test_merge.c
// Function: merge_into_suite
SUITE(merge_into_suite)
{
    int i;
    int c;

    for (i = 0; i < TEST_NUM; i++) {
        c = (rand() % ARR_SZ);
        if ((c < 0) || (c > ARR_SZ))
            continue;
        RUN_TEST1(do_merge_into_test, c);
    }

    RUN_TEST1(do_merge_into_test, 0);
    RUN_TEST1(do_merge_into_test, ARR_SZ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x80, -0x4(%rbp)
jge 0x1eab
callq 0x1170
movl $0x78fb, %ecx           # imm = 0x78FB
cltd
idivl %ecx
movl %edx, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x1e67
cmpl $0x78fb, -0x8(%rbp)     # imm = 0x78FB
jle 0x1e69
jmp 0x1ea0
jmp 0x1e6b
leaq 0x23cf(%rip), %rdi      # 0x4241
callq 0x17d0
cmpl $0x1, %eax
jne 0x1e9c
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1e94
movl -0x8(%rbp), %edi
callq 0x1f20
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x1cb0
jmp 0x1e9e
jmp 0x1ea0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1e3f
jmp 0x1ead
leaq 0x238d(%rip), %rdi      # 0x4241
callq 0x17d0
cmpl $0x1, %eax
jne 0x1edd
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x1ed5
xorl %edi, %edi
callq 0x1f20
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
callq 0x1cb0
jmp 0x1edf
jmp 0x1ee1
leaq 0x2359(%rip), %rdi      # 0x4241
callq 0x17d0
cmpl $0x1, %eax
jne 0x1f14
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1f0c
movl $0x78fb, %edi           # imm = 0x78FB
callq 0x1f20
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x1cb0
jmp 0x1f16
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/JulStrat[P]bams/tests/test_merge.c
// Function: main
int
main(int argc, char *argv[])
{
    GREATEST_MAIN_BEGIN();
#if defined(__STDC_VERSION__)
    printf("Compiler Standard version - %ld\n", __STDC_VERSION__);
#endif

    srand(time(NULL));

    RUN_SUITE(merge_suite);
    RUN_SUITE(merge_into_suite);

    GREATEST_MAIN_END();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2c00
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2ca0
leaq 0xfc6(%rip), %rdi       # 0x4384
movl $0x313ee, %esi          # imm = 0x313EE
movb $0x0, %al
callq 0x1090
xorl %eax, %eax
movl %eax, %edi
callq 0x1120
movl %eax, %edi
callq 0x10d0
leaq -0x1d01(%rip), %rdi     # 0x16e0
leaq 0xfbd(%rip), %rsi       # 0x43a5
callq 0x2c70
leaq -0x15c4(%rip), %rdi     # 0x1e30
leaq 0xfb6(%rip), %rsi       # 0x43b1
callq 0x2c70
callq 0x2ed0
callq 0x2760
movl %eax, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/run-tests.c
// Function: main
int main() {
  int sorted[N_ELEMENTS];
  int results[N_ELEMENTS][2];
  
  forwards_test(sorted, results);
  backwards_test(sorted, results);
  coprime_test(sorted, results);
  random_test(sorted, results);
  cleanup_test();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc00010, %rsp         # imm = 0xC00010
movl $0x0, -0x4(%rbp)
leaq -0x400010(%rbp), %rdi
leaq -0xc00010(%rbp), %rsi
callq 0x1260
leaq -0x400010(%rbp), %rdi
leaq -0xc00010(%rbp), %rsi
callq 0x13a0
leaq -0x400010(%rbp), %rdi
leaq -0xc00010(%rbp), %rsi
callq 0x14e0
leaq -0x400010(%rbp), %rdi
leaq -0xc00010(%rbp), %rsi
callq 0x1670
callq 0x1880
xorl %eax, %eax
addq $0xc00010, %rsp         # imm = 0xC00010
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/run-tests.c
// Function: forwards_test
static void forwards_test(int elems[], int results[][2]) {
  printf("----------FORWARDS TEST----------\n");
  printf("Inserting integers 0 to %d into a soft heap...\n", N_ELEMENTS - 1);
  softheap *P = makeheap_empty(EPSILON);
  for(int i = 0; i < N_ELEMENTS; i++) {
    elems[i] = i;
    insert(P, i);
  }
  
  int ckey_corruptions = 0, pos_corruptions = 0;
  printf("Extracting elements with ckeys...\n");
  for(int i = 0; i < N_ELEMENTS; i++) {
    results[i][0] = extract_min_with_ckey(P, &results[i][1]);
    if(results[i][0] < results[i][1]) ckey_corruptions++;
    if(results[i][0] != elems[i]) pos_corruptions++;
  }

  report_corruptions(ckey_corruptions, pos_corruptions, N_ELEMENTS);  
  free(P);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1da1(%rip), %rdi      # 0x3018
movb $0x0, %al
callq 0x1050
leaq 0x1db6(%rip), %rdi      # 0x303b
movl $0xfffff, %esi          # imm = 0xFFFFF
movb $0x0, %al
callq 0x1050
movsd 0x1d6f(%rip), %xmm0     # 0x3008
callq 0x19d0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x100000, -0x1c(%rbp)  # imm = 0x100000
jge 0x12d7
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1c40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12a9
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0x1d7f(%rip), %rdi      # 0x306b
movb $0x0, %al
callq 0x1050
movl $0x0, -0x28(%rbp)
cmpl $0x100000, -0x28(%rbp)  # imm = 0x100000
jge 0x137f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
addq $0x4, %rsi
callq 0x2080
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
cmpl 0x4(%rcx,%rdx,8), %eax
jge 0x134e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x8(%rbp), %rcx
movslq -0x28(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x136f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1371
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x12fa
movl -0x20(%rbp), %edi
movl -0x24(%rbp), %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x17f0
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/run-tests.c
// Function: backwards_test
static void backwards_test(int elems[], int results[][2]) {
  printf("----------BACKWARDS TEST----------\n");
  printf("Inserting integers 0 to %d into a soft heap in reverse order...\n", N_ELEMENTS - 1);
  softheap *P = makeheap_empty(EPSILON);
  for(int i = N_ELEMENTS - 1; i >= 0; i--) {
    elems[i] = i;
    insert(P, i);
  }
  
  int ckey_corruptions = 0, pos_corruptions = 0;
  printf("Extracting elements with ckeys...\n");
  for(int i = 0; i < N_ELEMENTS; i++) {
    results[i][0] = extract_min_with_ckey(P, &results[i][1]);
    if(results[i][0] < results[i][1]) ckey_corruptions++;
    if(results[i][0] != elems[i]) pos_corruptions++;
  }
  
  report_corruptions(ckey_corruptions, pos_corruptions, N_ELEMENTS);  
  free(P);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1d5f(%rip), %rdi      # 0x3116
movb $0x0, %al
callq 0x1050
leaq 0x1d75(%rip), %rdi      # 0x313a
movl $0xfffff, %esi          # imm = 0xFFFFF
movb $0x0, %al
callq 0x1050
movsd 0x1c2f(%rip), %xmm0     # 0x3008
callq 0x19d0
movq %rax, -0x18(%rbp)
movl $0xfffff, -0x1c(%rbp)   # imm = 0xFFFFF
cmpl $0x0, -0x1c(%rbp)
jl 0x1414
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1c40
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13e9
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0x1c42(%rip), %rdi      # 0x306b
movb $0x0, %al
callq 0x1050
movl $0x0, -0x28(%rbp)
cmpl $0x100000, -0x28(%rbp)  # imm = 0x100000
jge 0x14bc
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
addq $0x4, %rsi
callq 0x2080
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
cmpl 0x4(%rcx,%rdx,8), %eax
jge 0x148b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x8(%rbp), %rcx
movslq -0x28(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x14ac
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14ae
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1437
movl -0x20(%rbp), %edi
movl -0x24(%rbp), %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x17f0
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/run-tests.c
// Function: random_test
static void random_test(int elems[], int results[][2]) {
  srand(time(NULL));
  printf("----------RANDOM TEST----------\n");
  printf("Inserting %d random integers into a soft heap...\n", N_ELEMENTS);        

  softheap *P = makeheap_empty(EPSILON);
  for(int i = 0; i < N_ELEMENTS; i++) {
    int num = rand();
    elems[i] = num;
    insert(P, num);
  }

  printf("Sorting correctness array...\n");
  qsort(elems, N_ELEMENTS, sizeof(int), intcmp);
    
  int ckey_corruptions = 0, pos_corruptions = 0;
  printf("Extracting elements with ckeys...\n");
  for(int i = 0; i < N_ELEMENTS; i++) {
    results[i][0] = extract_min_with_ckey(P, &results[i][1]);
    if(results[i][0] < results[i][1]) ckey_corruptions++;
    if(results[i][0] != elems[i]) pos_corruptions++;
  }
  
  report_corruptions(ckey_corruptions, pos_corruptions, N_ELEMENTS);  
  free(P);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x1080
leaq 0x1b6c(%rip), %rdi      # 0x3203
movb $0x0, %al
callq 0x1050
leaq 0x1b7f(%rip), %rdi      # 0x3224
movl $0x100000, %esi         # imm = 0x100000
movb $0x0, %al
callq 0x1050
movsd 0x194f(%rip), %xmm0     # 0x3008
callq 0x19d0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x100000, -0x1c(%rbp)  # imm = 0x100000
jge 0x16ff
callq 0x10e0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x1c40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x16c9
leaq 0x1adf(%rip), %rdi      # 0x31e5
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
movl $0x100000, %esi         # imm = 0x100000
movl $0x4, %edx
leaq 0x13e(%rip), %rcx       # 0x1860
callq 0x1040
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
leaq 0x192f(%rip), %rdi      # 0x306b
movb $0x0, %al
callq 0x1050
movl $0x0, -0x2c(%rbp)
cmpl $0x100000, -0x2c(%rbp)  # imm = 0x100000
jge 0x17cf
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x2c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
addq $0x4, %rsi
callq 0x2080
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl 0x4(%rcx,%rdx,8), %eax
jge 0x179e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x8(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x17bf
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x17c1
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x174a
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x17f0
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/run-tests.c
// Function: report_corruptions
static void report_corruptions(int ckey_corruptions, int pos_corruptions, int nelems) {
  printf("\nTotal number of ckey corruptions: %d\nFraction corrupted: %4.3f\n", ckey_corruptions,
         (double)ckey_corruptions/nelems);
  printf("\nTotal number of positional corruptions: %d\nFraction corrupted: %4.3f\n", pos_corruptions,
         (double)pos_corruptions/nelems);
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %esi
cvtsi2sdl -0x4(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
leaq 0x1875(%rip), %rdi      # 0x308e
movb $0x1, %al
callq 0x1050
movl -0x8(%rbp), %esi
cvtsi2sdl -0x8(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
leaq 0x1897(%rip), %rdi      # 0x30cf
movb $0x1, %al
callq 0x1050
leaq 0x1aa2(%rip), %rdi      # 0x32e8
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/run-tests.c
// Function: cleanup_test
static void cleanup_test() {
  printf("----------CLEANUP TEST-----------\n");
  printf("Testing robustness of destroy_heap by creating and destroying "
         "100 soft heaps of increasing size...\n");

  srand(time(NULL));

  for(int i = 0; i < 100; i++) {
    int size = N_ELEMENTS / 100 * i;
    softheap *P = makeheap_empty(SORTED_EPSILON); // make heaps super branchy
    
    for(int j = 0; j < size; j++) insert(P, rand());

    destroy_heap(P);
    
    // Show progress
    printf(".");
    fflush(stdout);
    if(i % 10 == 9) printf("\n");
  }

  printf("Success!\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x19c7(%rip), %rdi      # 0x3256
movb $0x0, %al
callq 0x1050
leaq 0x19dc(%rip), %rdi      # 0x3279
movb $0x0, %al
callq 0x1050
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x1080
movl $0x0, -0x4(%rbp)
cmpl $0x64, -0x4(%rbp)
jge 0x1966
imull $0x28f5, -0x4(%rbp), %eax # imm = 0x28F5
movl %eax, -0x8(%rbp)
movsd 0x1739(%rip), %xmm0     # 0x3010
callq 0x19d0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1912
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x10e0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x1c40
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18e7
movq -0x10(%rbp), %rdi
callq 0x1b40
leaq 0x19bb(%rip), %rdi      # 0x32dd
movb $0x0, %al
callq 0x1050
movq 0x36b0(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
callq 0x10b0
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x9, %edx
jne 0x1956
leaq 0x1999(%rip), %rdi      # 0x32e8
movb $0x0, %al
callq 0x1050
jmp 0x1958
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x18bb
leaq 0x1972(%rip), %rdi      # 0x32df
movb $0x0, %al
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: makeheap
softheap *makeheap(int elem, double epsilon) {
  softheap *s = makeheap_empty(epsilon);
  s->first = maketree(elem);
  s->rank = 0;
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x19d0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
callq 0x1a60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: makeheap_empty
softheap *makeheap_empty(double epsilon) {
  // Ensure error parameter is valid
  if(epsilon <= 0 || epsilon >= 1) error(1,0, "Soft heap error parameter must fall in (0,1)");
  
  softheap *s = malloc(sizeof(softheap));
  s->first = NULL;
  s->rank = -1; // Ensures that any insertion will just return the SH containing the inserted elem
  s->epsilon = epsilon;
  s->r = get_r(epsilon);
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jae 0x19fa
movsd -0x8(%rbp), %xmm0
movsd 0x18fc(%rip), %xmm1     # 0x32f0
ucomisd %xmm1, %xmm0
jb 0x1a0f
movl $0x1, %edi
xorl %esi, %esi
leaq 0x1908(%rip), %rdx      # 0x3310
movb $0x0, %al
callq 0x10c0
movl $0x20, %edi
callq 0x10a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x8(%rbp), %xmm0
callq 0x1ad0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: maketree
static tree *maketree(int elem) {
  tree *T = malloc(sizeof(tree));
  T->root = makenode(elem);
  T->prev = T->next = NULL;
  T->rank = 0;
  T->sufmin = T;
  return T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x28, %edi
callq 0x10a0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0x2450
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: destroy_heap
void destroy_heap(softheap *P) {
  if(P == NULL) return;

  tree *curr = P->first, *next;
  while(curr != NULL) {
    next = curr->next;
    destroy_node(curr->root);
    free(curr);
    curr = next;
  }  

  free(P);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1b55
jmp 0x1b9c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1b93
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1bb0
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1b60
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: destroy_node
static void destroy_node(node *treenode) {
  if(treenode == NULL) return;
  
  cell *curr = treenode->first, *next;
  while(curr != NULL) {
    next = curr->next;
    free(curr);
    curr = next;
  }

  destroy_node(treenode->left);
  destroy_node(treenode->right);
  free(treenode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1bc5
jmp 0x1c19
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1bf7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1bd1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1bb0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1bb0
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: insert
void insert(softheap *P, int elem) {
  if(empty(P)) { 
    P->first = maketree(elem);
    P->rank = 0;
  } else meld(P, makeheap(elem, P->epsilon));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c20
testb $0x1, %al
jne 0x1c5e
jmp 0x1c7d
movl -0xc(%rbp), %edi
callq 0x1a60
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x1ca2
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
callq 0x1980
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x1cb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: meld
softheap *meld(softheap *P, softheap *Q) {
  // Do not allow melding if the soft heaps don't seem to have the same error parameter.
  double max_eps = max(P->epsilon, Q->epsilon), min_eps = min(P->epsilon, Q->epsilon);
  double eps_off = 1 - min_eps/max_eps; 
  if(eps_off > 0.001) error(1,0, "Tried to combine soft heaps with different epsilons");

  // If both softheaps empty, just destroy one and return the other
  if(empty(P) && empty(Q)) {
    free(P);
    return Q;
  }

  softheap *result;
  if(P->rank >= Q->rank) { // meld Q into P
    merge_into(Q, P);
    repeated_combine(P, Q->rank, P->r);
    free(Q);
    result = P;
  } else { // meld P into Q
    merge_into(P, Q);
    repeated_combine(Q, P->rank, Q->r);
    free(P);
    result = Q;
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm1
callq 0x1e00
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm1
callq 0x1e40
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
divsd -0x20(%rbp), %xmm1
movsd 0x15e6(%rip), %xmm0     # 0x32f0
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x15e8(%rip), %xmm1     # 0x3308
ucomisd %xmm1, %xmm0
jbe 0x1d3b
movl $0x1, %edi
xorl %esi, %esi
leaq 0x1609(%rip), %rdx      # 0x333d
movb $0x0, %al
callq 0x10c0
movq -0x10(%rbp), %rdi
callq 0x1c20
testb $0x1, %al
jne 0x1d4a
jmp 0x1d6f
movq -0x18(%rbp), %rdi
callq 0x1c20
testb $0x1, %al
jne 0x1d59
jmp 0x1d6f
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1df3
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x1db6
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e80
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x1f00
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1deb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e80
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x1f00
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: merge_into
static void merge_into(softheap *P, softheap *Q) {
  tree *currP = P->first, *currQ = Q->first;

  while(currP != NULL) {
    while(currQ->rank < currP->rank) currQ = currQ->next;
    // currQ is now the first tree in Q with rank >= currP. Insert currP before it.
    tree *next = currP->next;
    insert_tree(Q, currP, currQ);
    currP = next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1ef4
jmp 0x1eaf
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x1ecd
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1eaf
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2530
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x1ea6
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: extract_min_with_ckey
int extract_min_with_ckey(softheap *P, int *ckey_into) {
  if(empty(P)) error(1,0, "Tried to extract an element from an empty soft heap");

  tree *T = P->first->sufmin; // tree with lowest root ckey
  node *x = T->root;
  int e = extract_elem(x);
  *ckey_into = x->ckey;

  if(x->nelems <= x->size / 2) { // x is deficient; rescue it if possible
    if(!leaf(x)) {
      sift(x);
      update_suffix_min(T);
    } else if(x->nelems == 0) { // x is a leaf and empty; it must be destroyed
      free(x);
      remove_tree(P, T);

      if(T->next == NULL) { // we removed the highest-ranked tree; reset heap rank and clean up
        if(T->prev == NULL) P->rank = -1; // Heap now empty. Rank -1 is sentinel for future melds
        else P->rank = T->prev->rank;
      }

      if(T->prev != NULL) update_suffix_min(T->prev);
      free(T);
    }
  }

  return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c20
testb $0x1, %al
jne 0x209f
jmp 0x20b4
movl $0x1, %edi
xorl %esi, %esi
leaq 0x12c4(%rip), %rdx      # 0x3371
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x21b0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jg 0x21a7
movq -0x20(%rbp), %rdi
callq 0x2270
testb $0x1, %al
jne 0x212f
movq -0x20(%rbp), %rdi
callq 0x22a0
movq -0x18(%rbp), %rdi
callq 0x2380
jmp 0x21a5
movq -0x20(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x21a3
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x23f0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2184
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2171
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
jmp 0x2182
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x2184
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x219a
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2380
movq -0x18(%rbp), %rdi
callq 0x1030
jmp 0x21a5
jmp 0x21a7
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: extract_elem
static int extract_elem(node *x) {
  assert(x->first != NULL);
  cell *todelete = x->first;
  int result = todelete->elem;

  x->first = todelete->next;
  if(x->first == NULL) x->last = NULL;
  else if(x->first->next == NULL) x->last = x->first;

  free(todelete);
  x->nelems--;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x21c9
jmp 0x21e8
leaq 0x11d5(%rip), %rdi      # 0x33a5
leaq 0x11df(%rip), %rsi      # 0x33b6
movl $0x1a6, %edx            # imm = 0x1A6
leaq 0x11de(%rip), %rcx      # 0x33c1
callq 0x1060
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2226
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x2247
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2245
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x2247
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c(%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: sift
static void sift(node *x) {
  while(x->nelems < x->size && !leaf(x)) {
    // For simplicity, switch left and right children so that left child exists & has smaller ckey
    if(x->left == NULL || (x->right != NULL && x->left->ckey > x->right->ckey)) swapLR(x);
    moveList(x->left, x); // concat left's list to x's to replenish x
    x->ckey = x->left->ckey;

    // if left was a leaf, it can't be repaired, so destroy it
    if(leaf(x->left)) {
      free(x->left);
      x->left = NULL;
    } else {
      sift(x->left);
    }
  } // Repeat as necessary until x is repaired or until x is a leaf and no more repairs are possible
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpl 0x28(%rdx), %ecx
movb %al, -0x9(%rbp)
jge 0x22cf
movq -0x8(%rbp), %rdi
callq 0x2270
xorb $-0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x22db
jmp 0x236d
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2307
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2310
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x20(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x20(%rcx), %eax
jle 0x2310
movq -0x8(%rbp), %rdi
callq 0x2670
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x26a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2270
testb $0x1, %al
jne 0x2343
jmp 0x235c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x2368
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x22a0
jmp 0x22ac
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: update_suffix_min
static void update_suffix_min(tree *T) {
  while(T != NULL) {
    if(T->next == NULL || T->root->ckey <= T->next->sufmin->root->ckey) T->sufmin = T;
    else T->sufmin = T->next->sufmin;
    T = T->prev;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x23e9
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x23ba
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x20(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x20(%rcx), %eax
jg 0x23c8
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x23dc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2388
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: makenode
static node *makenode(int elem) {
  node *x = malloc(sizeof(node));
  x->first = x->last = addcell(elem, NULL);
  x->ckey = elem;
  x->rank = 0;
  x->size = x->nelems = 1;
  x->left = x->right = NULL;
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x30, %edi
callq 0x10a0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x24e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: addcell
static cell *addcell(int elem, cell *listend) {
  cell *c = malloc(sizeof(cell));
  c->elem = elem;
  if(listend != NULL) listend->next = c;
  c->next = NULL;
  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x10a0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x2519
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: insert_tree
static void insert_tree(softheap *into_heap, tree *inserted, tree *successor) {
  inserted->next = successor;

  if(successor->prev == NULL) into_heap->first = inserted;
  else successor->prev->next = inserted;
  inserted->prev = successor->prev;
  successor->prev = inserted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2563
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2572
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: combine
static node *combine(node *x, node *y, int r) {
  node *z = malloc(sizeof(node));
  z->left = x;
  z->right = y;
  z->rank = x->rank + 1;
  z->nelems = 0;
  z->first = z->last = NULL;

  z->size = get_next_size(z->rank, x->size, r);
  sift(z);
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x30, %edi
callq 0x10a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x24(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %esi
movl -0x14(%rbp), %edx
callq 0x2630
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x20(%rbp), %rdi
callq 0x22a0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/softheap.c
// Function: moveList
static void moveList(node *src, node *dst) {
  assert(src->first != NULL);
  if(dst->last != NULL) dst->last->next = src->first;
  else dst->first = src->first;
  dst->last = src->last;

  dst->nelems += src->nelems;
  src->nelems = 0;
  src->first = src->last = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x26bd
jmp 0x26dc
leaq 0xd16(%rip), %rdi       # 0x33da
leaq 0xceb(%rip), %rsi       # 0x33b6
movl $0xf8, %edx
leaq 0xd16(%rip), %rcx       # 0x33ed
callq 0x1060
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x26fd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x270d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/./common.h
// Function: stress_is_num
char
stress_is_num(char str[])
{
	int i = 0;
	for (; str[i] != 0; i++) {
		if (!isdigit(str[i]))
			return _STRESS_FALSE;
	}

	return _STRESS_TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1331
callq 0x11a0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x4(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x1322
movb $0x0, 0x17(%rsp)
jmp 0x1336
jmp 0x1324
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x12e1
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/./common.h
// Function: stress_wait_until_signalized
void
stress_wait_until_signalized()
{
	struct sigaction action;
	memset(&action, 0, sizeof(struct sigaction));
	action.sa_handler = stress_handle_sigint;
	sigaction(SIGINT, &action, NULL);

	printf("[%d] Waiting for SIGINT\n", getpid());
	sleep(36000);
}

// Assembly:
subq $0x98, %rsp
movq %rsp, %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x10e0
leaq -0x3d(%rip), %rax       # 0x1720
movq %rax, (%rsp)
movl $0x2, %edi
movq %rsp, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1070
callq 0x10a0
movl %eax, %esi
leaq 0x98c(%rip), %rdi       # 0x210c
movb $0x0, %al
callq 0x10d0
movl $0x8ca0, %edi           # imm = 0x8CA0
callq 0x1190
addq $0x98, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/./common.h
// Function: stress_write_n
ssize_t
stress_write_n(int fd, const void* vptr, size_t n)
{
	size_t nleft;
	ssize_t nwritten;
	const char* ptr;

	ptr = vptr;
	nleft = n;

	while (nleft > 0) {
		nwritten = write(fd, ptr, nleft);
		if (nwritten < 0) {
			if (errno == EINTR) {
				nwritten = 0;
				break;
			}

			return nwritten;
		}

		nleft -= nwritten;
		ptr += nwritten;
	}

	return n - nleft;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jbe 0x182e
movl 0x2c(%rsp), %edi
movq (%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1090
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jge 0x180d
callq 0x1040
cmpl $0x4, (%rax)
jne 0x1801
movq $0x0, 0x8(%rsp)
jmp 0x182e
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x183d
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq (%rsp), %rax
movq %rax, (%rsp)
jmp 0x17c5
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/./common.h
// Function: stress_read_n
ssize_t
stress_read_n(int fd, void* vptr, size_t n)
{
	size_t nleft;
	ssize_t nread;
	char* ptr;

	ptr = vptr;
	nleft = n;

	while (nleft > 0) {
		nread = read(fd, ptr, nleft);
		if (nread < 0) {
			if (errno == EINTR) {
				nread = 0;
				break;
			}

			return nread;
		}

		nleft -= nread;
		ptr += nread;
	}

	return n - nleft;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jbe 0x18de
movl 0x2c(%rsp), %edi
movq (%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x10f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jge 0x18bd
callq 0x1040
cmpl $0x4, (%rax)
jne 0x18b1
movq $0x0, 0x8(%rsp)
jmp 0x18de
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x18ed
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq (%rsp), %rax
movq %rax, (%rsp)
jmp 0x1875
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/locks-fcntl.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };

	setbuf(stdout, NULL);
	stress_parse_args(argc, argv, &args);

	create_files(args.n);
	stress_wait_until_signalized();

	return 0;
}

// Assembly:
subq $0x2018, %rsp           # imm = 0x2018
movl $0x0, 0x2014(%rsp)
movl %edi, 0x2010(%rsp)
movq %rsi, 0x2008(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x2008, %edx           # imm = 0x2008
callq 0x10e0
movq 0x2071(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10c0
movl 0x2010(%rsp), %edi
movq 0x2008(%rsp), %rsi
movq %rsp, %rdx
callq 0x1340
movl (%rsp), %edi
callq 0x1c90
callq 0x1740
xorl %eax, %eax
addq $0x2018, %rsp           # imm = 0x2018
retq
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: main
global int main(int argc, char** argv) {
  readcmdline(argv);
  if (options & opt_l) {
    computefilter();
    printresults(argv);
  } else
    printf("OK!\n");
  return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x12e0
movl 0x7e0b(%rip), %eax      # 0x90b0
andl $0x1, %eax
cmpl $0x0, %eax
je 0x12be
callq 0x1610
movq 0x8(%rsp), %rdi
callq 0x1690
jmp 0x12cc
leaq 0x1dbb(%rip), %rdi      # 0x3080
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: computefilter()
static void computefilter() {
  switch (options & (opt_c | opt_r | opt_h | opt_i)) {
    default:
      giveup("Must have exactly one of -{crhi}");

    case opt_c:
    case opt_r:
    case opt_i:
      initcircle();
      compute_rc();
      apply_window();
      trunc_coeffs();
      break;

    case opt_h:
      if (options & opt_x)
        giveup("Can't combine -h with -x");
      compute_ht();
      apply_window();
      trunc_coeffs();
      break;
  }
}

// Assembly:
pushq %rax
movl 0x7a99(%rip), %eax      # 0x90b0
andl $0x1e, %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0xe, %eax
ja 0x163c
movq (%rsp), %rax
leaq 0x19d1(%rip), %rcx      # 0x3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b78(%rip), %rdi      # 0x31bb
xorl %esi, %esi
callq 0x1aa0
callq 0x1b00
callq 0x1b90
callq 0x20a0
callq 0x21a0
jmp 0x168b
movl 0x7a4a(%rip), %eax      # 0x90b0
andl $0x40, %eax
cmpl $0x0, %eax
je 0x167c
leaq 0x1b67(%rip), %rdi      # 0x31dc
xorl %esi, %esi
callq 0x1aa0
callq 0x22d0
callq 0x20a0
callq 0x21a0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: usage()
static void usage() {
  fprintf(stderr, "Mkshape V.%s from <fisher@minster.york.ac.uk>\n", VERSION);
  fprintf(stderr,
          "Usage: mkshape -{cr} <alpha> <beta> <len> [-{lwx}] [-b nb]\n");
  fprintf(stderr, "       mkshape -i <len> [-{lwx}] [-b nb]\n");
  fprintf(stderr, "       mkshape -h <len> [-{lw}] [-b nb]\n");
  exit(1);
}

// Assembly:
pushq %rax
movq 0x35f8(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x16fd(%rip), %rsi      # 0x30ef
leaq 0x1725(%rip), %rdx      # 0x311e
movb $0x0, %al
callq 0x10b0
movq 0x35d9(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1711(%rip), %rsi      # 0x3122
movb $0x0, %al
callq 0x10b0
movq 0x35c1(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1735(%rip), %rsi      # 0x315e
movb $0x0, %al
callq 0x10b0
movq 0x35a9(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1747(%rip), %rsi      # 0x3188
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x1080
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: giveup(char const*, int)
static void giveup(const char* msg, int p1) {
  fprintf(stderr, "mkshape: ");
  fprintf(stderr, msg, p1);
  putc('\n', stderr);
  exit(1);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x352c(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x16f3(%rip), %rsi      # 0x31b1
movb $0x0, %al
callq 0x10b0
movq 0x3514(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movb $0x0, %al
callq 0x10b0
movq 0x34fa(%rip), %rax      # 0x4fe0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1110
movl $0x1, %edi
callq 0x1080
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: apply_window()
static void apply_window() /* apply Hamming window to impulse response */
{
  if (options & opt_w) {
    int h = (numcoeffs - 1) / 2;
    for (int i = 1; i <= h; i++) {
      double w =
          0.54 - 0.46 * cos(TWOPI * (double)(h + i) / (double)(numcoeffs - 1));
      xcoeffs[h + i] *= w;
      xcoeffs[h - i] *= w;
    }
  }
}

// Assembly:
subq $0x18, %rsp
movl 0x7006(%rip), %eax      # 0x90b0
andl $0x20, %eax
cmpl $0x0, %eax
je 0x2191
movl 0x6ffc(%rip), %eax      # 0x90b8
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x14(%rsp)
movl $0x1, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jg 0x218f
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
cvtsi2sd %eax, %xmm1
movsd 0xf5b(%rip), %xmm0      # 0x3050
mulsd %xmm1, %xmm0
movl 0x6fb9(%rip), %eax      # 0x90b8
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
callq 0x1100
movsd 0xf59(%rip), %xmm1      # 0x3070
mulsd %xmm1, %xmm0
movsd 0xf55(%rip), %xmm1      # 0x3078
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
movslq %eax, %rcx
leaq 0x6f8b(%rip), %rax      # 0x90d0
mulsd (%rax,%rcx,8), %xmm0
leaq 0x6f7f(%rip), %rax      # 0x90d0
movsd %xmm0, (%rax,%rcx,8)
movsd 0x8(%rsp), %xmm0
movl 0x14(%rsp), %eax
subl 0x10(%rsp), %eax
movslq %eax, %rcx
leaq 0x6f62(%rip), %rax      # 0x90d0
mulsd (%rax,%rcx,8), %xmm0
leaq 0x6f56(%rip), %rax      # 0x90d0
movsd %xmm0, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x20d3
jmp 0x2191
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)