LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_directthreaded_tailcall.c
// Function: OP_Add
void OP_Add(PARAMS)
{
    uint32_t op = arr0->data[pc];
    uint32_t a = (op >> 6) & 7;
    uint32_t b = (op >> 3) & 7;
    uint32_t c = op & 7;
    reg[a] = reg[b] + reg[c];
    ++pc;
    MUSTTAIL return program[pc](ARGS);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, -0x18(%rsp)
movl -0x14(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, -0x1c(%rsp)
movl -0x14(%rsp), %eax
andl $0x7, %eax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, %ecx
leaq 0x3aa0(%rip), %rax      # 0x50d0
movl (%rax,%rcx,4), %edx
movl -0x20(%rsp), %ecx
movl (%rax,%rcx,4), %ecx
addl %ecx, %edx
movl -0x18(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rsp), %rax
incq %rax
movq %rax, -0x8(%rsp)
movq 0x3ab1(%rip), %rax      # 0x5108
movq -0x8(%rsp), %rdi
movq (%rax,%rdi,8), %rax
movq -0x10(%rsp), %rsi
jmpq *%rax
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_directthreaded_tailcall.c
// Function: OP_Div
void OP_Div(PARAMS)
{
    uint32_t op = arr0->data[pc];
    uint32_t a = (op >> 6) & 7;
    uint32_t b = (op >> 3) & 7;
    uint32_t c = op & 7;
    assert(reg[c] != 0);
    reg[a] = reg[b] / reg[c];
    ++pc;
    MUSTTAIL return program[pc](ARGS);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, %ecx
leaq 0x397c(%rip), %rax      # 0x50d0
cmpl $0x0, (%rax,%rcx,4)
je 0x175c
jmp 0x177b
leaq 0x1958(%rip), %rdi      # 0x30bb
leaq 0x18a6(%rip), %rsi      # 0x3010
movl $0x6f, %edx
leaq 0x1951(%rip), %rcx      # 0x30c7
callq 0x1080
movl 0xc(%rsp), %eax
leaq 0x394a(%rip), %rcx      # 0x50d0
movq %rcx, (%rsp)
movl (%rcx,%rax,4), %eax
movl 0x8(%rsp), %edx
movl (%rcx,%rdx,4), %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %edx
movq (%rsp), %rax
movl 0x10(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
incq %rax
movq %rax, 0x20(%rsp)
movq 0x394f(%rip), %rax      # 0x5108
movq 0x20(%rsp), %rdi
movq (%rax,%rdi,8), %rax
movq 0x18(%rsp), %rsi
addq $0x28, %rsp
jmpq *%rax
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_directthreaded_tailcall.c
// Function: OP_Alloc
void OP_Alloc(PARAMS)
{
    uint32_t op = arr0->data[pc];
    uint32_t b = (op >> 3) & 7;
    uint32_t c = op & 7;
    uint32_t capacity = reg[c];
    uint32_t i = 0;
    if (freelist_end == freelist) {
        i = arrsize;
        ++arrsize;
        arr = realloc(arr, sizeof(struct array *) * arrsize);
        assert(arr != NULL);
    } else {
        i = *(--freelist_end);
        *freelist_end = 0;
    }
    struct array *newarr = calloc(1 + capacity, sizeof(uint32_t));
    assert(newarr != NULL);
    newarr->length = capacity;
    arr[i] = newarr;
    reg[b] = i;
    ++pc;
    MUSTTAIL return program[pc](ARGS);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %ecx
leaq 0x37ea(%rip), %rax      # 0x50d0
movl (%rax,%rcx,4), %eax
movl %eax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x37fc(%rip), %rax      # 0x50f8
cmpq 0x37ed(%rip), %rax      # 0x50f0
jne 0x196d
movq 0x37ac(%rip), %rax      # 0x50b8
movl %eax, 0x14(%rsp)
movq 0x37a1(%rip), %rax      # 0x50b8
addq $0x1, %rax
movq %rax, 0x3796(%rip)      # 0x50b8
movq 0x37e7(%rip), %rdi      # 0x5110
movq 0x3788(%rip), %rsi      # 0x50b8
shlq $0x3, %rsi
callq 0x1120
movq %rax, 0x37d0(%rip)      # 0x5110
cmpq $0x0, 0x37c8(%rip)      # 0x5110
je 0x194c
jmp 0x196b
leaq 0x17c7(%rip), %rdi      # 0x311a
leaq 0x16b6(%rip), %rsi      # 0x3010
movl $0x91, %edx
leaq 0x178b(%rip), %rcx      # 0x30f1
callq 0x1080
jmp 0x1996
movq 0x3784(%rip), %rax      # 0x50f8
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, 0x3776(%rip)      # 0x50f8
movl -0x4(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x3768(%rip), %rax      # 0x50f8
movl $0x0, (%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
movl $0x4, %esi
callq 0x10a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x19ba
jmp 0x19d9
leaq 0x1756(%rip), %rdi      # 0x3117
leaq 0x1648(%rip), %rsi      # 0x3010
movl $0x97, %edx
leaq 0x171d(%rip), %rcx      # 0x30f1
callq 0x1080
movl 0x18(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rdx
movq 0x3720(%rip), %rax      # 0x5110
movl 0x14(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %edx
movl 0x20(%rsp), %eax
movl %eax, %ecx
leaq 0x36c7(%rip), %rax      # 0x50d0
movl %edx, (%rax,%rcx,4)
movq 0x30(%rsp), %rax
incq %rax
movq %rax, 0x30(%rsp)
movq 0x36e8(%rip), %rax      # 0x5108
movq 0x30(%rsp), %rdi
movq (%rax,%rdi,8), %rax
movq 0x28(%rsp), %rsi
addq $0x38, %rsp
jmpq *%rax
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_directthreaded_tailcall.c
// Function: OP_Output
void OP_Output(PARAMS)
{
    uint32_t op = arr0->data[pc];
    uint32_t c = op & 7;
    assert(reg[c] <= 255);
    putchar(reg[c]);
    ++pc;
    MUSTTAIL return program[pc](ARGS);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
andl $0x7, %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, %ecx
leaq 0x346a(%rip), %rax      # 0x50d0
cmpl $0xff, (%rax,%rcx,4)
ja 0x1c71
jmp 0x1c90
leaq 0x14ec(%rip), %rdi      # 0x3164
leaq 0x1391(%rip), %rsi      # 0x3010
movl $0xb7, %edx
leaq 0x14e7(%rip), %rcx      # 0x3172
callq 0x1080
movl (%rsp), %eax
movl %eax, %ecx
leaq 0x3434(%rip), %rax      # 0x50d0
movl (%rax,%rcx,4), %edi
callq 0x1040
movq 0x10(%rsp), %rax
incq %rax
movq %rax, 0x10(%rsp)
movq 0x3450(%rip), %rax      # 0x5108
movq 0x10(%rsp), %rdi
movq (%rax,%rdi,8), %rax
movq 0x8(%rsp), %rsi
addq $0x18, %rsp
jmpq *%rax
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_directthreaded_tailcall.c
// Function: OP_Input
void OP_Input(PARAMS)
{
    uint32_t op = arr0->data[pc];
    uint32_t c = op & 7;
    fflush(stdout);
    int ch = getchar();
    if (ch == EOF) {
        reg[c] = (uint32_t)(-1);
    } else {
        assert(0 <= ch && ch <= 255);
        reg[c] = (uint32_t)ch;
    }
    ++pc;
    MUSTTAIL return program[pc](ARGS);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x10(%rsp)
movq 0x32ce(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x1100
callq 0x10b0
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jne 0x1d30
movl 0x10(%rsp), %eax
movl %eax, %ecx
leaq 0x33a9(%rip), %rax      # 0x50d0
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x1d77
xorl %eax, %eax
cmpl 0xc(%rsp), %eax
jg 0x1d44
cmpl $0xff, 0xc(%rsp)
jg 0x1d44
jmp 0x1d63
leaq 0x144e(%rip), %rdi      # 0x3199
leaq 0x12be(%rip), %rsi      # 0x3010
movl $0xc5, %edx
leaq 0x1450(%rip), %rcx      # 0x31ae
callq 0x1080
movl 0xc(%rsp), %edx
movl 0x10(%rsp), %eax
movl %eax, %ecx
leaq 0x335c(%rip), %rax      # 0x50d0
movl %edx, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
incq %rax
movq %rax, 0x20(%rsp)
movq 0x337d(%rip), %rax      # 0x5108
movq 0x20(%rsp), %rdi
movq (%rax,%rdi,8), %rax
movq 0x18(%rsp), %rsi
addq $0x28, %rsp
jmpq *%rax
nop
// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_directthreaded_tailcall.c
// Function: OP_LoadProgram
void OP_LoadProgram(PARAMS)
{
    uint32_t op = arr0->data[pc];
    uint32_t b = (op >> 3) & 7;
    uint32_t c = op & 7;
    uint32_t i = reg[b];
    if (UNLIKELY(i != 0)) {
        assert(i < arrsize);
        assert(arr[i] != NULL);
        uint32_t length = arr[i]->length;
        struct array *newprogram = malloc((length + 1) * sizeof(uint32_t));
        assert(newprogram != NULL);
        memcpy(newprogram, arr[i], (length + 1) * sizeof(uint32_t));
        free(arr[0]);
        arr[0] = newprogram;
        arr0 = newprogram;
        recalc();
    }
    pc = reg[c];
    assert(pc < arr[0]->length);
    MUSTTAIL return program[pc](ARGS);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x1c(%rsp)
movl 0x20(%rsp), %eax
movl %eax, %ecx
leaq 0x32ea(%rip), %rax      # 0x50d0
movl (%rax,%rcx,4), %eax
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x1f17
movl 0x18(%rsp), %eax
cmpq 0x32a3(%rip), %rax      # 0x50b8
jae 0x1e19
jmp 0x1e38
leaq 0x11e4(%rip), %rdi      # 0x3004
leaq 0x11e9(%rip), %rsi      # 0x3010
movl $0xd2, %edx
leaq 0x13a1(%rip), %rcx      # 0x31d4
callq 0x1080
movq 0x32d1(%rip), %rax      # 0x5110
movl 0x18(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x1e4c
jmp 0x1e6b
leaq 0x1302(%rip), %rdi      # 0x3155
leaq 0x11b6(%rip), %rsi      # 0x3010
movl $0xd3, %edx
leaq 0x136e(%rip), %rcx      # 0x31d4
callq 0x1080
movq 0x329e(%rip), %rax      # 0x5110
movl 0x18(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x10f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1ea3
jmp 0x1ec2
leaq 0x1356(%rip), %rdi      # 0x3200
leaq 0x115f(%rip), %rsi      # 0x3010
movl $0xd6, %edx
leaq 0x1317(%rip), %rcx      # 0x31d4
callq 0x1080
movq 0x8(%rsp), %rdi
movq 0x3242(%rip), %rax      # 0x5110
movl 0x18(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x10e0
movq 0x321f(%rip), %rax      # 0x5110
movq (%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rcx
movq 0x320b(%rip), %rax      # 0x5110
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x1f80
movl 0x1c(%rsp), %eax
movl %eax, %ecx
leaq 0x31ac(%rip), %rax      # 0x50d0
movl (%rax,%rcx,4), %eax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x31d8(%rip), %rcx      # 0x5110
movq (%rcx), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x1f44
jmp 0x1f63
leaq 0x12c8(%rip), %rdi      # 0x3213
leaq 0x10be(%rip), %rsi      # 0x3010
movl $0xde, %edx
leaq 0x1276(%rip), %rcx      # 0x31d4
callq 0x1080
movq 0x319e(%rip), %rax      # 0x5108
movq 0x30(%rsp), %rdi
movq (%rax,%rdi,8), %rax
movq 0x28(%rsp), %rsi
addq $0x38, %rsp
jmpq *%rax
nop
// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_directthreaded_tailcall.c
// Function: recalc
void recalc(void)
{
    struct array *a0 = arr[0];
    uint32_t length = a0->length;
    if (program) {
        free(program);
    }
    program = malloc(sizeof(OP) * length);
    assert(program != NULL);
    for (uint32_t i = 0; i < length; ++i) {
        uint32_t op = a0->data[i];
        program[i] = operations[op >> 28];
    }
}

// Assembly:
subq $0x18, %rsp
movq 0x3185(%rip), %rax      # 0x5110
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
cmpq $0x0, 0x3162(%rip)      # 0x5108
je 0x1fb4
movq 0x3159(%rip), %rdi      # 0x5108
callq 0x1030
movl 0xc(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x10f0
movq %rax, 0x313e(%rip)      # 0x5108
cmpq $0x0, 0x3136(%rip)      # 0x5108
je 0x1fd6
jmp 0x1ff5
leaq 0x12cb(%rip), %rdi      # 0x32a8
leaq 0x102c(%rip), %rsi      # 0x3010
movl $0x10b, %edx            # imm = 0x10B
leaq 0x1252(%rip), %rcx      # 0x3242
callq 0x1080
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jae 0x204a
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %ecx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2d36(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rdx
movq 0x30d3(%rip), %rax      # 0x5108
movl 0x8(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1ffd
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_directthreaded_tailcall.c
// Function: OP_Orthography
void OP_Orthography(PARAMS)
{
    uint32_t op = arr0->data[pc];
    uint32_t a = (op >> 25) & 7;
    uint32_t value = op & ((UINT32_C(1) << 25) - 1);
    reg[a] = value;
    ++pc;
    MUSTTAIL return program[pc](ARGS);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
shrl $0x19, %eax
andl $0x7, %eax
movl %eax, -0x18(%rsp)
movl -0x14(%rsp), %eax
andl $0x1ffffff, %eax        # imm = 0x1FFFFFF
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %edx
movl -0x18(%rsp), %eax
movl %eax, %ecx
leaq 0x3038(%rip), %rax      # 0x50d0
movl %edx, (%rax,%rcx,4)
movq -0x8(%rsp), %rax
incq %rax
movq %rax, -0x8(%rsp)
movq 0x3059(%rip), %rax      # 0x5108
movq -0x8(%rsp), %rdi
movq (%rax,%rdi,8), %rax
movq -0x10(%rsp), %rsi
jmpq *%rax
nop
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/./vl/mathop.h
// Function: vl_fast_resqrt_d
VL_INLINE double
vl_fast_resqrt_d (double x)
{
  /* 64-bit version */
  union {
    double x ;
    vl_int64  i ;
  } u ;

  double xhalf = (double) 0.5 * x ;

  /* convert floating point value in RAW integer */
  u.x = x ;

  /* gives initial guess y0 */
#ifdef VL_COMPILER_MSC
  u.i = 0x5fe6ec85e7de30dai64 - (u.i >> 1) ;
#else
  u.i = 0x5fe6ec85e7de30daLL - (u.i >> 1) ;
#endif

  /* two Newton steps */
  u.x = u.x * ( (double) 1.5  - xhalf*u.x*u.x) ;
  u.x = u.x * ( (double) 1.5  - xhalf*u.x*u.x) ;
  return u.x ;
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movsd 0x107a(%rip), %xmm0     # 0x3058
mulsd -0x8(%rsp), %xmm0
movsd %xmm0, -0x18(%rsp)
movsd -0x8(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
movq -0x10(%rsp), %rcx
sarq %rcx
movabsq $0x5fe6ec85e7de30da, %rax # imm = 0x5FE6EC85E7DE30DA
subq %rcx, %rax
movq %rax, -0x10(%rsp)
movsd -0x10(%rsp), %xmm0
movsd -0x18(%rsp), %xmm1
mulsd -0x10(%rsp), %xmm1
movsd -0x10(%rsp), %xmm2
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
movsd 0x1005(%rip), %xmm2     # 0x3050
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rsp)
movsd -0x10(%rsp), %xmm0
movsd -0x18(%rsp), %xmm1
mulsd -0x10(%rsp), %xmm1
movsd -0x10(%rsp), %xmm2
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
movsd 0xfbc(%rip), %xmm2      # 0x3050
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rsp)
movsd -0x10(%rsp), %xmm0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/activation_test.c
// Function: test_sigmoid
void test_sigmoid() {
  double x[] = {10e10, 0, -10e10};
  double y[3];
  double expected[] = {1, 0.5, 0};
  int n = sizeof(x)/sizeof(x[0]);
  morpheus_sigmoid(n, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, y, n);
}

// Assembly:
subq $0x68, %rsp
movq 0x9d95(%rip), %rax      # 0xb010
movq %rax, 0x50(%rsp)
movq 0x9d91(%rip), %rax      # 0xb018
movq %rax, 0x58(%rsp)
movq 0x9d8d(%rip), %rax      # 0xb020
movq %rax, 0x60(%rsp)
movq 0x9d91(%rip), %rax      # 0xb030
movq %rax, 0x10(%rsp)
movq 0x9d8d(%rip), %rax      # 0xb038
movq %rax, 0x18(%rsp)
movq 0x9d89(%rip), %rax      # 0xb040
movq %rax, 0x20(%rsp)
movl $0x3, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x4df0
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl 0xc(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0xb, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/activation_test.c
// Function: test_sigmoid_gradient
void test_sigmoid_gradient() {
  double x[] = {10e10, 0, -10e10};
  double y[3];
  double expected[] = {0, 0.25, 0};
  int n = sizeof(x)/sizeof(x[0]);
  morpheus_sigmoid_gradient(n, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, y, n);
}

// Assembly:
subq $0x68, %rsp
movq 0x9d45(%rip), %rax      # 0xb050
movq %rax, 0x50(%rsp)
movq 0x9d41(%rip), %rax      # 0xb058
movq %rax, 0x58(%rsp)
movq 0x9d3d(%rip), %rax      # 0xb060
movq %rax, 0x60(%rsp)
movq 0x9d41(%rip), %rax      # 0xb070
movq %rax, 0x10(%rsp)
movq 0x9d3d(%rip), %rax      # 0xb078
movq %rax, 0x18(%rsp)
movq 0x9d39(%rip), %rax      # 0xb080
movq %rax, 0x20(%rsp)
movl $0x3, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x4e80
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl 0xc(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x14, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/activation_test.c
// Function: test_relu
void test_relu() {
  double x[] = {10e10, 0, -10e10};
  double y[3];
  double expected[] = {10e10, 0, 0};
  int n = sizeof(x)/sizeof(x[0]);
  morpheus_relu(n, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, y, n);
}

// Assembly:
subq $0x68, %rsp
movq 0x9cf5(%rip), %rax      # 0xb090
movq %rax, 0x50(%rsp)
movq 0x9cf1(%rip), %rax      # 0xb098
movq %rax, 0x58(%rsp)
movq 0x9ced(%rip), %rax      # 0xb0a0
movq %rax, 0x60(%rsp)
movq 0x9cf1(%rip), %rax      # 0xb0b0
movq %rax, 0x10(%rsp)
movq 0x9ced(%rip), %rax      # 0xb0b8
movq %rax, 0x18(%rsp)
movq 0x9ce9(%rip), %rax      # 0xb0c0
movq %rax, 0x20(%rsp)
movl $0x3, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x4f30
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl 0xc(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x1d, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/activation_test.c
// Function: test_relu_gradient
void test_relu_gradient() {
  double x[] = {10e10, 0, -10e10};
  double y[3];
  double expected[] = {1, 0, 0};
  int n = sizeof(x)/sizeof(x[0]);
  morpheus_relu_gradient(n, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, y, n);
}

// Assembly:
subq $0x68, %rsp
movq 0x9ca5(%rip), %rax      # 0xb0d0
movq %rax, 0x50(%rsp)
movq 0x9ca1(%rip), %rax      # 0xb0d8
movq %rax, 0x58(%rsp)
movq 0x9c9d(%rip), %rax      # 0xb0e0
movq %rax, 0x60(%rsp)
movq 0x9ca1(%rip), %rax      # 0xb0f0
movq %rax, 0x10(%rsp)
movq 0x9c9d(%rip), %rax      # 0xb0f8
movq %rax, 0x18(%rsp)
movq 0x9c99(%rip), %rax      # 0xb100
movq %rax, 0x20(%rsp)
movl $0x3, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x4fb0
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl 0xc(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x26, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/activation_test.c
// Function: test_tanh
void test_tanh() {
  double x[] = {10e10, 0, -10e10};
  double y[3];
  double expected[] = {1, 0, -1};
  int n = sizeof(x)/sizeof(x[0]);
  morpheus_tanh(n, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, y, n);
}

// Assembly:
subq $0x68, %rsp
movq 0x9c55(%rip), %rax      # 0xb110
movq %rax, 0x50(%rsp)
movq 0x9c51(%rip), %rax      # 0xb118
movq %rax, 0x58(%rsp)
movq 0x9c4d(%rip), %rax      # 0xb120
movq %rax, 0x60(%rsp)
movq 0x9c51(%rip), %rax      # 0xb130
movq %rax, 0x10(%rsp)
movq 0x9c4d(%rip), %rax      # 0xb138
movq %rax, 0x18(%rsp)
movq 0x9c49(%rip), %rax      # 0xb140
movq %rax, 0x20(%rsp)
movl $0x3, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x5020
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl 0xc(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x2f, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/activation_test.c
// Function: test_tanh_gradient
void test_tanh_gradient() {
  double x[] = {10e10, 0, -10e10};
  double y[3];
  double expected[] = {0, 1, 0};
  int n = sizeof(x)/sizeof(x[0]);
  morpheus_tanh_gradient(n, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, y, n);
}

// Assembly:
subq $0x68, %rsp
movq 0x9c05(%rip), %rax      # 0xb150
movq %rax, 0x50(%rsp)
movq 0x9c01(%rip), %rax      # 0xb158
movq %rax, 0x58(%rsp)
movq 0x9bfd(%rip), %rax      # 0xb160
movq %rax, 0x60(%rsp)
movq 0x9c01(%rip), %rax      # 0xb170
movq %rax, 0x10(%rsp)
movq 0x9bfd(%rip), %rax      # 0xb178
movq %rax, 0x18(%rsp)
movq 0x9bf9(%rip), %rax      # 0xb180
movq %rax, 0x20(%rsp)
movl $0x3, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x5080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl 0xc(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x38, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/gradient_descent_test.c
// Function: test_gradient_descent
void test_gradient_descent() {
  double X[] = {
    1, 3,
    1, 5,
    1, 10,
    1, 0,
    1, 4
  };
  double y[] = {9, 13, 23, 3, 11};

  double theta[] = {1, 1};
  double tmp_buffer[2*5];

  morpheus_params_t data;
  data.data.x = X;
  data.data.y = y;
  data.data.num_features = 2;
  data.data.num_examples = 5;
  data.data.layout = morpheus_row_major;
  data.memory_buffer = tmp_buffer;
  data.reg.type = morpheus_reg_none;

  double tmp_buffer2[2*5];
  morpheus_gradient_descent_params_t params;
  params.f = (morpheus_f)morpheus_ls_cost;
  params.df = (morpheus_df)morpheus_ls_gradient;
  params.max_iters = 4000;
  params.epsilon = 1e-10;
  params.alpha = 1e-2;
  params.memory_buffer = tmp_buffer2;
  params.num_variables = data.data.num_features;

  double theta_expected[] = {3, 2};
  morpheus_gradient_descent(&params, theta, &data);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(theta_expected, theta, data.data.num_features);
}

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x170(%rsp), %rdi
leaq 0x9bda(%rip), %rsi      # 0xb1c0
movl $0x50, %edx
callq 0x1150
leaq 0x140(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x9bac(%rip), %xmm0     # 0xb1b8
movsd %xmm0, 0x140(%rsp)
movsd 0x9b93(%rip), %xmm0     # 0xb1b0
movsd %xmm0, 0x148(%rsp)
movsd 0x9b7a(%rip), %xmm0     # 0xb1a8
movsd %xmm0, 0x150(%rsp)
movsd 0x9b61(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0x158(%rsp)
movsd 0x9b48(%rip), %xmm0     # 0xb198
movsd %xmm0, 0x160(%rsp)
movq 0x9bb0(%rip), %rax      # 0xb210
movq %rax, 0x130(%rsp)
movq 0x9ba9(%rip), %rax      # 0xb218
movq %rax, 0x138(%rsp)
leaq 0x170(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0x140(%rsp), %rax
movq %rax, 0xb0(%rsp)
movl $0x2, 0xb8(%rsp)
movl $0x5, 0xbc(%rsp)
movl $0x15, 0xc0(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0xd8(%rsp)
movl $0x0, 0xc8(%rsp)
leaq 0x3f86(%rip), %rax      # 0x5660
movq %rax, 0x18(%rsp)
leaq 0x3fba(%rip), %rax      # 0x56a0
movq %rax, 0x20(%rsp)
movl $0xfa0, 0x28(%rsp)      # imm = 0xFA0
movsd 0x9a95(%rip), %xmm0     # 0xb190
movsd %xmm0, 0x30(%rsp)
movsd 0x9a7f(%rip), %xmm0     # 0xb188
movsd %xmm0, 0x38(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movl 0xb8(%rsp), %eax
movl %eax, 0x40(%rsp)
movq 0x9af5(%rip), %rax      # 0xb220
movq %rax, (%rsp)
movq 0x9af2(%rip), %rax      # 0xb228
movq %rax, 0x8(%rsp)
leaq 0x130(%rsp), %rsi
leaq 0x18(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0x5290
movq %rsp, %rdi
leaq 0x130(%rsp), %rsi
movl 0xb8(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x28, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x1c8, %rsp            # imm = 0x1C8
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/matrix_reduce_test.c
// Function: test_column_pred
void test_column_pred() {
  double x[] = {
    71, 11, 3,  9, 7,
    21, 7,  2,  23, 11,
    11, 32, 53, 49, 37,
    1,  24, 78, 90, 17
  };

  double y[5];

  double expected_row_major[] = {1, 7, 2, 9, 7};
  morpheus_column_predicate(fmin, morpheus_row_major, 4, 5, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_row_major, y, 5);

  double expected_col_major[] = {3, 2, 11, 1};
  morpheus_column_predicate(fmin, morpheus_col_major, 5, 4, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_col_major, y, 4);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
leaq 0x80(%rsp), %rdi
leaq 0x97ca(%rip), %rsi      # 0xb620
movl $0xa0, %edx
callq 0x1150
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x9747(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x20(%rsp)
movsd 0x9729(%rip), %xmm0     # 0xb5b0
movsd %xmm0, 0x28(%rsp)
movsd 0x9723(%rip), %xmm0     # 0xb5b8
movsd %xmm0, 0x30(%rsp)
movsd 0x9315(%rip), %xmm0     # 0xb1b8
movsd %xmm0, 0x38(%rsp)
movsd 0x96ff(%rip), %xmm0     # 0xb5b0
movsd %xmm0, 0x40(%rsp)
leaq 0x80(%rsp), %r8
leaq 0x50(%rsp), %r9
movq 0xe0fd(%rip), %rdi      # 0xffc8
movl $0x15, %esi
movl $0x4, %edx
movl $0x5, %ecx
callq 0x56e0
leaq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movl $0x5, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x13, %r8d
movl $0x1, %r9d
callq 0x8ec0
movq 0x9c96(%rip), %rax      # 0xbba0
movq %rax, (%rsp)
movq 0x9c93(%rip), %rax      # 0xbba8
movq %rax, 0x8(%rsp)
movq 0x9c8f(%rip), %rax      # 0xbbb0
movq %rax, 0x10(%rsp)
movq 0x9c8b(%rip), %rax      # 0xbbb8
movq %rax, 0x18(%rsp)
leaq 0x80(%rsp), %r8
leaq 0x50(%rsp), %r9
movq 0xe082(%rip), %rdi      # 0xffc8
movl $0x16, %esi
movl $0x5, %edx
movl $0x4, %ecx
callq 0x56e0
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x17, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/matrix_reduce_test.c
// Function: test_row_pred
void test_row_pred() {
  double x[] = {
    71, 11, 3,  9, 7,
    21, 7,  2,  23, 11,
    11, 32, 53, 49, 37,
    1,  24, 78, 90, 17
  };

  double y[5];

  double expected_row_major[] = {71, 23, 53, 90};
  morpheus_row_predicate(fmax, morpheus_row_major, 4, 5, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_row_major, y, 4);

  double expected_col_major[] = {71, 32, 78, 90, 37};
  morpheus_row_predicate(fmax, morpheus_col_major, 5, 4, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_col_major, y, 5);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
leaq 0x80(%rsp), %rdi
leaq 0x971a(%rip), %rsi      # 0xb6c0
movl $0xa0, %edx
callq 0x1150
movq 0x9c09(%rip), %rax      # 0xbbc0
movq %rax, 0x30(%rsp)
movq 0x9c05(%rip), %rax      # 0xbbc8
movq %rax, 0x38(%rsp)
movq 0x9c01(%rip), %rax      # 0xbbd0
movq %rax, 0x40(%rsp)
movq 0x9bfd(%rip), %rax      # 0xbbd8
movq %rax, 0x48(%rsp)
leaq 0x80(%rsp), %r8
leaq 0x50(%rsp), %r9
movq 0xdff4(%rip), %rdi      # 0xffe8
movl $0x15, %esi
movl $0x4, %edx
movl $0x5, %ecx
callq 0x58b0
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x26, %r8d
movl $0x1, %r9d
callq 0x8ec0
movq %rsp, %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x95a5(%rip), %xmm0     # 0xb5e8
movsd %xmm0, (%rsp)
movsd 0x9590(%rip), %xmm0     # 0xb5e0
movsd %xmm0, 0x8(%rsp)
movsd 0x957a(%rip), %xmm0     # 0xb5d8
movsd %xmm0, 0x10(%rsp)
movsd 0x9564(%rip), %xmm0     # 0xb5d0
movsd %xmm0, 0x18(%rsp)
movsd 0x954e(%rip), %xmm0     # 0xb5c8
movsd %xmm0, 0x20(%rsp)
leaq 0x80(%rsp), %r8
leaq 0x50(%rsp), %r9
movq 0xdf54(%rip), %rdi      # 0xffe8
movl $0x16, %esi
movl $0x5, %edx
movl $0x4, %ecx
callq 0x58b0
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
movl $0x5, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x2a, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/matrix_reduce_test.c
// Function: test_column_max_index
void test_column_max_index() {
  double x[] = {
    71, 11, 3,  9, 7,
    21, 7,  2,  23, 11,
    11, 32, 53, 49, 37,
    1,  24, 78, 90, 17
  };

  double y[5];
  int is[5];

  double expected_y_row_major[] = {71, 32, 78, 90, 37};
  int expected_is_row_major[] = {0, 2, 3, 3, 2};
  morpheus_column_max_index(morpheus_row_major, 4, 5, x, y, is);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y_row_major, y, 5);
  TEST_ASSERT_EQUAL_INT_ARRAY(expected_is_row_major, is, 5);

  double expected_y_col_major[] = {71, 23, 53, 90};
  int expected_is_col_major[] = {0, 3, 2, 3};
  morpheus_column_max_index(morpheus_col_major, 5, 4, x, y, is);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y_col_major, y, 4);
  TEST_ASSERT_EQUAL_INT_ARRAY(expected_is_col_major, is, 4);
}

// Assembly:
subq $0x188, %rsp            # imm = 0x188
leaq 0xe0(%rsp), %rdi
leaq 0x966a(%rip), %rsi      # 0xb760
movl $0xa0, %edx
callq 0x1150
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x94cf(%rip), %xmm0     # 0xb5e8
movsd %xmm0, 0x60(%rsp)
movsd 0x94b9(%rip), %xmm0     # 0xb5e0
movsd %xmm0, 0x68(%rsp)
movsd 0x94a3(%rip), %xmm0     # 0xb5d8
movsd %xmm0, 0x70(%rsp)
movsd 0x948d(%rip), %xmm0     # 0xb5d0
movsd %xmm0, 0x78(%rsp)
movsd 0x9477(%rip), %xmm0     # 0xb5c8
movsd %xmm0, 0x80(%rsp)
movq 0x969f(%rip), %rax      # 0xb800
movq %rax, 0x40(%rsp)
movq 0x969b(%rip), %rax      # 0xb808
movq %rax, 0x48(%rsp)
movl 0x9698(%rip), %eax      # 0xb810
movl %eax, 0x50(%rsp)
leaq 0xe0(%rsp), %rcx
leaq 0xb0(%rsp), %r8
leaq 0x90(%rsp), %r9
movl $0x15, %edi
movl $0x4, %esi
movl $0x5, %edx
callq 0x5a80
leaq 0x60(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
movl $0x5, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x3b, %r8d
movl $0x1, %r9d
callq 0x8ec0
leaq 0x40(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movl $0x5, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x3c, %r8d
movl $0x14, %r9d
movl $0x1, (%rsp)
callq 0x83b0
movq 0x99bc(%rip), %rax      # 0xbbc0
movq %rax, 0x20(%rsp)
movq 0x99b8(%rip), %rax      # 0xbbc8
movq %rax, 0x28(%rsp)
movq 0x99b4(%rip), %rax      # 0xbbd0
movq %rax, 0x30(%rsp)
movq 0x99b0(%rip), %rax      # 0xbbd8
movq %rax, 0x38(%rsp)
movq 0x99cc(%rip), %rax      # 0xbc00
movq %rax, 0x10(%rsp)
movq 0x99c8(%rip), %rax      # 0xbc08
movq %rax, 0x18(%rsp)
leaq 0xe0(%rsp), %rcx
leaq 0xb0(%rsp), %r8
leaq 0x90(%rsp), %r9
movl $0x16, %edi
movl $0x5, %esi
movl $0x4, %edx
callq 0x5a80
leaq 0x20(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x41, %r8d
movl $0x1, %r9d
callq 0x8ec0
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x42, %r8d
movl $0x14, %r9d
movl $0x1, (%rsp)
callq 0x83b0
addq $0x188, %rsp            # imm = 0x188
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/matrix_reduce_test.c
// Function: test_column_min_index
void test_column_min_index() {
  double x[] = {
    71, 11, 3,  9, 7,
    21, 7,  2,  23, 11,
    11, 32, 53, 49, 37,
    1,  24, 78, 90, 17
  };

  double y[5];
  int is[5];

  double expected_y_row_major[] = {1, 7, 2, 9, 7};
  int expected_is_row_major[] = {3, 1, 1, 0, 0};
  morpheus_column_min_index(morpheus_row_major, 4, 5, x, y, is);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y_row_major, y, 5);
  TEST_ASSERT_EQUAL_INT_ARRAY(expected_is_row_major, is, 5);

  double expected_y_col_major[] = {3, 2, 11, 1};
  int expected_is_col_major[] = {2, 2, 0, 0};
  morpheus_column_min_index(morpheus_col_major, 5, 4, x, y, is);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y_col_major, y, 4);
  TEST_ASSERT_EQUAL_INT_ARRAY(expected_is_col_major, is, 4);
}

// Assembly:
subq $0x188, %rsp            # imm = 0x188
leaq 0xe0(%rsp), %rdi
leaq 0x953a(%rip), %rsi      # 0xb820
movl $0xa0, %edx
callq 0x1150
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x92b7(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x60(%rsp)
movsd 0x9299(%rip), %xmm0     # 0xb5b0
movsd %xmm0, 0x68(%rsp)
movsd 0x9293(%rip), %xmm0     # 0xb5b8
movsd %xmm0, 0x70(%rsp)
movsd 0x8e85(%rip), %xmm0     # 0xb1b8
movsd %xmm0, 0x78(%rsp)
movsd 0x926f(%rip), %xmm0     # 0xb5b0
movsd %xmm0, 0x80(%rsp)
movq 0x956f(%rip), %rax      # 0xb8c0
movq %rax, 0x40(%rsp)
movq 0x956b(%rip), %rax      # 0xb8c8
movq %rax, 0x48(%rsp)
movl 0x9568(%rip), %eax      # 0xb8d0
movl %eax, 0x50(%rsp)
leaq 0xe0(%rsp), %rcx
leaq 0xb0(%rsp), %r8
leaq 0x90(%rsp), %r9
movl $0x15, %edi
movl $0x4, %esi
movl $0x5, %edx
callq 0x5ce0
leaq 0x60(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
movl $0x5, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x53, %r8d
movl $0x1, %r9d
callq 0x8ec0
leaq 0x40(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movl $0x5, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x54, %r8d
movl $0x14, %r9d
movl $0x1, (%rsp)
callq 0x83b0
movq 0x97ac(%rip), %rax      # 0xbba0
movq %rax, 0x20(%rsp)
movq 0x97a8(%rip), %rax      # 0xbba8
movq %rax, 0x28(%rsp)
movq 0x97a4(%rip), %rax      # 0xbbb0
movq %rax, 0x30(%rsp)
movq 0x97a0(%rip), %rax      # 0xbbb8
movq %rax, 0x38(%rsp)
movq 0x97ec(%rip), %rax      # 0xbc10
movq %rax, 0x10(%rsp)
movq 0x97e8(%rip), %rax      # 0xbc18
movq %rax, 0x18(%rsp)
leaq 0xe0(%rsp), %rcx
leaq 0xb0(%rsp), %r8
leaq 0x90(%rsp), %r9
movl $0x16, %edi
movl $0x5, %esi
movl $0x4, %edx
callq 0x5ce0
leaq 0x20(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x59, %r8d
movl $0x1, %r9d
callq 0x8ec0
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x5a, %r8d
movl $0x14, %r9d
movl $0x1, (%rsp)
callq 0x83b0
addq $0x188, %rsp            # imm = 0x188
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/matrix_reduce_test.c
// Function: test_row_max_index
void test_row_max_index() {
  double x[] = {
    71, 11, 3,  9, 7,
    21, 7,  2,  23, 11,
    11, 32, 53, 49, 37,
    1,  24, 78, 90, 17
  };

  double y[5];
  int is[5];

  double expected_y_row_major[] = {71, 23, 53, 90};
  int expected_is_row_major[] = {0, 3, 2, 3};
  morpheus_row_max_index(morpheus_row_major, 4, 5, x, y, is);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y_row_major, y, 4);

  double expected_y_col_major[] = {71, 32, 78, 90, 37};
  int expected_is_col_major[] = {0, 2, 3, 3, 2};
  morpheus_row_max_index(morpheus_col_major, 5, 4, x, y, is);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y_col_major, y, 5);
}

// Assembly:
subq $0x178, %rsp            # imm = 0x178
leaq 0xd0(%rsp), %rdi
leaq 0x940a(%rip), %rsi      # 0xb8e0
movl $0xa0, %edx
callq 0x1150
movq 0x96d9(%rip), %rax      # 0xbbc0
movq %rax, 0x60(%rsp)
movq 0x96d5(%rip), %rax      # 0xbbc8
movq %rax, 0x68(%rsp)
movq 0x96d1(%rip), %rax      # 0xbbd0
movq %rax, 0x70(%rsp)
movq 0x96cd(%rip), %rax      # 0xbbd8
movq %rax, 0x78(%rsp)
movq 0x96e9(%rip), %rax      # 0xbc00
movq %rax, 0x50(%rsp)
movq 0x96e5(%rip), %rax      # 0xbc08
movq %rax, 0x58(%rsp)
leaq 0xd0(%rsp), %rcx
leaq 0xa0(%rsp), %r8
leaq 0x80(%rsp), %r9
movl $0x15, %edi
movl $0x4, %esi
movl $0x5, %edx
callq 0x5f30
leaq 0x60(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x6b, %r8d
movl $0x1, %r9d
callq 0x8ec0
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x9054(%rip), %xmm0     # 0xb5e8
movsd %xmm0, 0x20(%rsp)
movsd 0x903e(%rip), %xmm0     # 0xb5e0
movsd %xmm0, 0x28(%rsp)
movsd 0x9028(%rip), %xmm0     # 0xb5d8
movsd %xmm0, 0x30(%rsp)
movsd 0x9012(%rip), %xmm0     # 0xb5d0
movsd %xmm0, 0x38(%rsp)
movsd 0x8ffc(%rip), %xmm0     # 0xb5c8
movsd %xmm0, 0x40(%rsp)
movq 0x93a7(%rip), %rax      # 0xb980
movq %rax, (%rsp)
movq 0x93a4(%rip), %rax      # 0xb988
movq %rax, 0x8(%rsp)
movl 0x93a1(%rip), %eax      # 0xb990
movl %eax, 0x10(%rsp)
leaq 0xd0(%rsp), %rcx
leaq 0xa0(%rsp), %r8
leaq 0x80(%rsp), %r9
movl $0x16, %edi
movl $0x5, %esi
movl $0x4, %edx
callq 0x5f30
leaq 0x20(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
movl $0x5, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x70, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x178, %rsp            # imm = 0x178
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/matrix_reduce_test.c
// Function: test_row_min_index
void test_row_min_index() {
  double x[] = {
    71, 11, 3,  9, 7,
    21, 7,  2,  23, 11,
    11, 32, 53, 49, 37,
    1,  24, 78, 90, 17
  };

  double y[5];
  int is[5];

  double expected_y_row_major[] = {3, 2, 11, 1};
  int expected_is_row_major[] = {2, 2, 0, 0};
  morpheus_row_min_index(morpheus_row_major, 4, 5, x, y, is);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y_row_major, y, 4);

  double expected_y_col_major[] = {1, 7, 2, 9, 7};
  int expected_is_col_major[] = {3, 1, 1, 0, 0};
  morpheus_row_min_index(morpheus_col_major, 5, 4, x, y, is);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y_col_major, y, 5);
}

// Assembly:
subq $0x178, %rsp            # imm = 0x178
leaq 0xd0(%rsp), %rdi
leaq 0x933a(%rip), %rsi      # 0xb9a0
movl $0xa0, %edx
callq 0x1150
movq 0x9529(%rip), %rax      # 0xbba0
movq %rax, 0x60(%rsp)
movq 0x9525(%rip), %rax      # 0xbba8
movq %rax, 0x68(%rsp)
movq 0x9521(%rip), %rax      # 0xbbb0
movq %rax, 0x70(%rsp)
movq 0x951d(%rip), %rax      # 0xbbb8
movq %rax, 0x78(%rsp)
movq 0x9569(%rip), %rax      # 0xbc10
movq %rax, 0x50(%rsp)
movq 0x9565(%rip), %rax      # 0xbc18
movq %rax, 0x58(%rsp)
leaq 0xd0(%rsp), %rcx
leaq 0xa0(%rsp), %r8
leaq 0x80(%rsp), %r9
movl $0x15, %edi
movl $0x4, %esi
movl $0x5, %edx
callq 0x6190
leaq 0x60(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x81, %r8d
movl $0x1, %r9d
callq 0x8ec0
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x8e9c(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x20(%rsp)
movsd 0x8e7e(%rip), %xmm0     # 0xb5b0
movsd %xmm0, 0x28(%rsp)
movsd 0x8e78(%rip), %xmm0     # 0xb5b8
movsd %xmm0, 0x30(%rsp)
movsd 0x8a6a(%rip), %xmm0     # 0xb1b8
movsd %xmm0, 0x38(%rsp)
movsd 0x8e54(%rip), %xmm0     # 0xb5b0
movsd %xmm0, 0x40(%rsp)
movq 0x92d7(%rip), %rax      # 0xba40
movq %rax, (%rsp)
movq 0x92d4(%rip), %rax      # 0xba48
movq %rax, 0x8(%rsp)
movl 0x92d1(%rip), %eax      # 0xba50
movl %eax, 0x10(%rsp)
leaq 0xd0(%rsp), %rcx
leaq 0xa0(%rsp), %r8
leaq 0x80(%rsp), %r9
movl $0x16, %edi
movl $0x5, %esi
movl $0x4, %edx
callq 0x6190
leaq 0x20(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
movl $0x5, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x86, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x178, %rsp            # imm = 0x178
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/matrix_reduce_test.c
// Function: test_column_sum
void test_column_sum() {
  double x[] = {
    71, 11, 3,  9, 7,
    21, 7,  2,  23, 11,
    11, 32, 53, 49, 37,
    1,  24, 78, 90, 17
  };

  double y[5];

  double expected_y_row_major[] = {104, 74, 136, 171, 72};
  morpheus_column_sum(morpheus_row_major, 4, 5, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y_row_major, y, 5);

  double expected_y_col_major[] = {101, 64,182, 210};
  morpheus_column_sum(morpheus_col_major, 5, 4, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y_col_major, y, 4);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
leaq 0x80(%rsp), %rdi
leaq 0x926a(%rip), %rsi      # 0xba60
movl $0xa0, %edx
callq 0x1150
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x8df7(%rip), %xmm0     # 0xb610
movsd %xmm0, 0x20(%rsp)
movsd 0x8de1(%rip), %xmm0     # 0xb608
movsd %xmm0, 0x28(%rsp)
movsd 0x8dcb(%rip), %xmm0     # 0xb600
movsd %xmm0, 0x30(%rsp)
movsd 0x8db5(%rip), %xmm0     # 0xb5f8
movsd %xmm0, 0x38(%rsp)
movsd 0x8d9f(%rip), %xmm0     # 0xb5f0
movsd %xmm0, 0x40(%rsp)
leaq 0x80(%rsp), %rcx
leaq 0x50(%rsp), %r8
movl $0x15, %edi
movl $0x4, %esi
movl $0x5, %edx
callq 0x63e0
leaq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movl $0x5, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x95, %r8d
movl $0x1, %r9d
callq 0x8ec0
movq 0x933d(%rip), %rax      # 0xbbe0
movq %rax, (%rsp)
movq 0x933a(%rip), %rax      # 0xbbe8
movq %rax, 0x8(%rsp)
movq 0x9336(%rip), %rax      # 0xbbf0
movq %rax, 0x10(%rsp)
movq 0x9332(%rip), %rax      # 0xbbf8
movq %rax, 0x18(%rsp)
leaq 0x80(%rsp), %rcx
leaq 0x50(%rsp), %r8
movl $0x16, %edi
movl $0x5, %esi
movl $0x4, %edx
callq 0x63e0
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x99, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/matrix_reduce_test.c
// Function: test_row_sum
void test_row_sum() {
  double x[] = {
    71, 11, 3,  9, 7,
    21, 7,  2,  23, 11,
    11, 32, 53, 49, 37,
    1,  24, 78, 90, 17
  };

  double y[5];

  double expected_y_row_major[] = {101, 64,182, 210};
  morpheus_row_sum(morpheus_row_major, 4, 5, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y_row_major, y, 4);

  double expected_y_col_major[] = {104, 74, 136, 171, 72};
  morpheus_row_sum(morpheus_col_major, 5, 4, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y_col_major, y, 5);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
leaq 0x80(%rsp), %rdi
leaq 0x91ca(%rip), %rsi      # 0xbb00
movl $0xa0, %edx
callq 0x1150
movq 0x9299(%rip), %rax      # 0xbbe0
movq %rax, 0x30(%rsp)
movq 0x9295(%rip), %rax      # 0xbbe8
movq %rax, 0x38(%rsp)
movq 0x9291(%rip), %rax      # 0xbbf0
movq %rax, 0x40(%rsp)
movq 0x928d(%rip), %rax      # 0xbbf8
movq %rax, 0x48(%rsp)
leaq 0x80(%rsp), %rcx
leaq 0x50(%rsp), %r8
movl $0x15, %edi
movl $0x4, %esi
movl $0x5, %edx
callq 0x65a0
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0xa8, %r8d
movl $0x1, %r9d
callq 0x8ec0
movq %rsp, %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x8c44(%rip), %xmm0     # 0xb610
movsd %xmm0, (%rsp)
movsd 0x8c2f(%rip), %xmm0     # 0xb608
movsd %xmm0, 0x8(%rsp)
movsd 0x8c19(%rip), %xmm0     # 0xb600
movsd %xmm0, 0x10(%rsp)
movsd 0x8c03(%rip), %xmm0     # 0xb5f8
movsd %xmm0, 0x18(%rsp)
movsd 0x8bed(%rip), %xmm0     # 0xb5f0
movsd %xmm0, 0x20(%rsp)
leaq 0x80(%rsp), %rcx
leaq 0x50(%rsp), %r8
movl $0x16, %edi
movl $0x5, %esi
movl $0x4, %edx
callq 0x65a0
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
movl $0x5, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0xac, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_inverse
void test_inverse() {
  double x[] = {1.0, 0.0, 2.0,
                -1.0, 5.0, 0.0,
                0.0, 3.0, -9.0};

  const int n = 3;
  double inversed_x[] =
    {0.88235294117647067, -0.11764705882352944, 0.19607843137254904,
     0.17647058823529416, 0.17647058823529413, 0.03921568627450981,
     0.058823529411764663, 0.058823529411764719, -0.098039215686274522};

  int pivot[n];
  double workspace[n*n];

  int rc = morpheus_inverse(n, x, pivot, workspace);

  TEST_ASSERT_EQUAL_INT(0, rc);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(inversed_x, x, n*n);
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
leaq 0xc0(%rsp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x1040
movsd 0x88fd(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0xc0(%rsp)
movsd 0x88e4(%rip), %xmm0     # 0xb5b8
movsd %xmm0, 0xd0(%rsp)
movsd 0x8fbb(%rip), %xmm0     # 0xbca0
movsd %xmm0, 0xd8(%rsp)
movsd 0x8fa2(%rip), %xmm0     # 0xbc98
movsd %xmm0, 0xe0(%rsp)
movsd 0x8499(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0xf8(%rsp)
movsd 0x8f78(%rip), %xmm0     # 0xbc90
movsd %xmm0, 0x100(%rsp)
movl $0x3, 0xbc(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x9008(%rip), %rsi      # 0xbd40
movl $0x48, %edx
callq 0x1150
movq %rsp, %rax
movq %rax, 0x68(%rsp)
leaq 0xc0(%rsp), %rsi
movl $0x3, %edi
leaq 0x50(%rsp), %rdx
movq %rsp, %rcx
callq 0x6b50
movl %eax, 0x64(%rsp)
movslq 0x64(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x14, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x8300
leaq 0x70(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movl $0x9, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x15, %r8d
movl $0x1, %r9d
callq 0x8ec0
movq 0x68(%rsp), %rax
movq %rax, %rsp
addq $0x108, %rsp            # imm = 0x108
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_ger_rm
void test_ger_rm() {
  double x[] = {1, 2, 3};
  double y[] = {4, 5, 6};
  double a[] = {29, 23, 19,
                17, 13, 11,
                7, 3, 1};
  double alpha = -1;
  double n = 3;

  double expected_a[] = {25, 18, 13,
                         9, 3, -1,
                         -5, -12, -17};
  morpheus_dger(morpheus_row_major, n, n, alpha, x, y, a);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_a, a, n*n);
}

// Assembly:
subq $0xf8, %rsp
movaps 0x8fc2(%rip), %xmm0     # 0xbd90
movaps %xmm0, 0xe0(%rsp)
movabsq $0x4008000000000000, %rax # imm = 0x4008000000000000
movq %rax, 0xf0(%rsp)
movabsq $0x4018000000000000, %rcx # imm = 0x4018000000000000
movq %rcx, 0xd0(%rsp)
movaps 0x8faf(%rip), %xmm0     # 0xbdb0
movaps %xmm0, 0xc0(%rsp)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0xb0(%rsp)
movaps 0x8fde(%rip), %xmm0     # 0xbe00
movaps %xmm0, 0xa0(%rsp)
movaps 0x8fbf(%rip), %xmm0     # 0xbdf0
movaps %xmm0, 0x90(%rsp)
movaps 0x8fa0(%rip), %xmm0     # 0xbde0
movaps %xmm0, 0x80(%rsp)
movaps 0x8f81(%rip), %xmm0     # 0xbdd0
movaps %xmm0, 0x70(%rsp)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, 0x68(%rsp)
movq %rax, 0x60(%rsp)
movabsq $-0x3fcf000000000000, %rax # imm = 0xC031000000000000
movq %rax, 0x50(%rsp)
movaps 0x8fd2(%rip), %xmm0     # 0xbe50
movaps %xmm0, 0x40(%rsp)
movaps 0x8fb6(%rip), %xmm0     # 0xbe40
movaps %xmm0, 0x30(%rsp)
movaps 0x8f9a(%rip), %xmm0     # 0xbe30
movaps %xmm0, 0x20(%rsp)
movaps 0x8f7e(%rip), %xmm0     # 0xbe20
movaps %xmm0, 0x10(%rsp)
cvttsd2si 0x60(%rsp), %edx
movsd 0x68(%rsp), %xmm0
movl $0x15, %edi
leaq 0xe0(%rsp), %rcx
leaq 0xc0(%rsp), %r8
leaq 0x70(%rsp), %r9
movq %r9, 0x8(%rsp)
movl %edx, %esi
callq 0x6c00
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movsd 0x60(%rsp), %xmm0
mulsd %xmm0, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x26, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_ger_cm
void test_ger_cm() {
  double x[] = {1, 2, 3};
  double y[] = {4, 5, 6};
  double a[] = {29, 23, 19,
                17, 13, 11,
                7, 3, 1};
  double alpha = -1;
  double n = 3;

  double expected_a[] = {25, 15, 7,
                         12, 3, -4,
                         1, -9, -17};
  morpheus_dger(morpheus_col_major, n, n, alpha, x, y, a);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_a, a, n*n);
}

// Assembly:
subq $0xf8, %rsp
movaps 0x8f42(%rip), %xmm0     # 0xbe70
movaps %xmm0, 0xe0(%rsp)
movabsq $0x4008000000000000, %rax # imm = 0x4008000000000000
movq %rax, 0xf0(%rsp)
movabsq $0x4018000000000000, %rcx # imm = 0x4018000000000000
movq %rcx, 0xd0(%rsp)
movaps 0x8f2f(%rip), %xmm0     # 0xbe90
movaps %xmm0, 0xc0(%rsp)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0xb0(%rsp)
movaps 0x8f5e(%rip), %xmm0     # 0xbee0
movaps %xmm0, 0xa0(%rsp)
movaps 0x8f3f(%rip), %xmm0     # 0xbed0
movaps %xmm0, 0x90(%rsp)
movaps 0x8f20(%rip), %xmm0     # 0xbec0
movaps %xmm0, 0x80(%rsp)
movaps 0x8f01(%rip), %xmm0     # 0xbeb0
movaps %xmm0, 0x70(%rsp)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, 0x68(%rsp)
movq %rax, 0x60(%rsp)
movabsq $-0x3fcf000000000000, %rax # imm = 0xC031000000000000
movq %rax, 0x50(%rsp)
movaps 0x8f52(%rip), %xmm0     # 0xbf30
movaps %xmm0, 0x40(%rsp)
movaps 0x8f36(%rip), %xmm0     # 0xbf20
movaps %xmm0, 0x30(%rsp)
movaps 0x8f1a(%rip), %xmm0     # 0xbf10
movaps %xmm0, 0x20(%rsp)
movaps 0x8efe(%rip), %xmm0     # 0xbf00
movaps %xmm0, 0x10(%rsp)
cvttsd2si 0x60(%rsp), %edx
movsd 0x68(%rsp), %xmm0
movl $0x16, %edi
leaq 0xe0(%rsp), %rcx
leaq 0xc0(%rsp), %r8
leaq 0x70(%rsp), %r9
movq %r9, 0x8(%rsp)
movl %edx, %esi
callq 0x6c00
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movsd 0x60(%rsp), %xmm0
mulsd %xmm0, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x36, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)