LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_ger_rm_nonsquare
void test_ger_rm_nonsquare() {
  double x[] = {1, 2, 3, 4};
  double y[] = {5, 6, 7};
  double a[] = {41, 37, 31,
                29, 23, 19,
                17, 13, 11,
                7, 3, 1};
  double alpha = -2;
  double m = 4;
  double n = 3;

  double expected_a[] = {31, 25, 17,
                         9, -1, -9,
                         -13, -23, -31,
                         -33, -45, -55};
  morpheus_dger(morpheus_row_major, m, n, alpha, x, y, a);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_a, a, m*n);
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movaps 0x98d2(%rip), %xmm0     # 0xc960
movaps %xmm0, 0x120(%rsp)
movaps 0x98b3(%rip), %xmm0     # 0xc950
movaps %xmm0, 0x110(%rsp)
movabsq $0x401c000000000000, %rax # imm = 0x401C000000000000
movq %rax, 0x100(%rsp)
movaps 0x8e92(%rip), %xmm0     # 0xbf50
movaps %xmm0, 0xf0(%rsp)
movaps 0x8ef3(%rip), %xmm0     # 0xbfc0
movaps %xmm0, 0xe0(%rsp)
movaps 0x8ed4(%rip), %xmm0     # 0xbfb0
movaps %xmm0, 0xd0(%rsp)
movaps 0x8eb5(%rip), %xmm0     # 0xbfa0
movaps %xmm0, 0xc0(%rsp)
movaps 0x8e96(%rip), %xmm0     # 0xbf90
movaps %xmm0, 0xb0(%rsp)
movaps 0x8e77(%rip), %xmm0     # 0xbf80
movaps %xmm0, 0xa0(%rsp)
movaps 0x8e58(%rip), %xmm0     # 0xbf70
movaps %xmm0, 0x90(%rsp)
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
movq %rax, 0x88(%rsp)
movabsq $0x4010000000000000, %rax # imm = 0x4010000000000000
movq %rax, 0x80(%rsp)
movabsq $0x4008000000000000, %rax # imm = 0x4008000000000000
movq %rax, 0x78(%rsp)
movaps 0x8ec6(%rip), %xmm0     # 0xc020
movaps %xmm0, 0x60(%rsp)
movaps 0x8eaa(%rip), %xmm0     # 0xc010
movaps %xmm0, 0x50(%rsp)
movaps 0x8e8e(%rip), %xmm0     # 0xc000
movaps %xmm0, 0x40(%rsp)
movaps 0x8e72(%rip), %xmm0     # 0xbff0
movaps %xmm0, 0x30(%rsp)
movaps 0x8e56(%rip), %xmm0     # 0xbfe0
movaps %xmm0, 0x20(%rsp)
movaps 0x8e3a(%rip), %xmm0     # 0xbfd0
movaps %xmm0, 0x10(%rsp)
cvttsd2si 0x80(%rsp), %esi
cvttsd2si 0x78(%rsp), %edx
movsd 0x88(%rsp), %xmm0
movl $0x15, %edi
leaq 0x110(%rsp), %rcx
leaq 0xf0(%rsp), %r8
leaq 0x90(%rsp), %r9
movq %r9, 0x8(%rsp)
callq 0x6c00
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movsd 0x80(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x49, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x138, %rsp            # imm = 0x138
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_ger_cm_nonsquare
void test_ger_cm_nonsquare() {
  double x[] = {1, 2, 3, 4};
  double y[] = {5, 6, 7};
  double a[] = {41, 37, 31, 29,
                23, 19, 17, 13,
                11, 7, 3, 1};
  double alpha = -2;
  double m = 4;
  double n = 3;

  double expected_a[] = {31, 17, 1, -11,
                         11, -5, -19, -35,
                         -3,-21, -39, -55};
  morpheus_dger(morpheus_col_major, m, n, alpha, x, y, a);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_a, a, m*n);
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movaps 0x9732(%rip), %xmm0     # 0xc960
movaps %xmm0, 0x120(%rsp)
movaps 0x9713(%rip), %xmm0     # 0xc950
movaps %xmm0, 0x110(%rsp)
movabsq $0x401c000000000000, %rax # imm = 0x401C000000000000
movq %rax, 0x100(%rsp)
movaps 0x8dd2(%rip), %xmm0     # 0xc030
movaps %xmm0, 0xf0(%rsp)
movaps 0x8e33(%rip), %xmm0     # 0xc0a0
movaps %xmm0, 0xe0(%rsp)
movaps 0x8e14(%rip), %xmm0     # 0xc090
movaps %xmm0, 0xd0(%rsp)
movaps 0x8df5(%rip), %xmm0     # 0xc080
movaps %xmm0, 0xc0(%rsp)
movaps 0x8dd6(%rip), %xmm0     # 0xc070
movaps %xmm0, 0xb0(%rsp)
movaps 0x8db7(%rip), %xmm0     # 0xc060
movaps %xmm0, 0xa0(%rsp)
movaps 0x8d98(%rip), %xmm0     # 0xc050
movaps %xmm0, 0x90(%rsp)
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
movq %rax, 0x88(%rsp)
movabsq $0x4010000000000000, %rax # imm = 0x4010000000000000
movq %rax, 0x80(%rsp)
movabsq $0x4008000000000000, %rax # imm = 0x4008000000000000
movq %rax, 0x78(%rsp)
movaps 0x8e06(%rip), %xmm0     # 0xc100
movaps %xmm0, 0x60(%rsp)
movaps 0x8dea(%rip), %xmm0     # 0xc0f0
movaps %xmm0, 0x50(%rsp)
movaps 0x8dce(%rip), %xmm0     # 0xc0e0
movaps %xmm0, 0x40(%rsp)
movaps 0x8db2(%rip), %xmm0     # 0xc0d0
movaps %xmm0, 0x30(%rsp)
movaps 0x8d96(%rip), %xmm0     # 0xc0c0
movaps %xmm0, 0x20(%rsp)
movaps 0x8d7a(%rip), %xmm0     # 0xc0b0
movaps %xmm0, 0x10(%rsp)
cvttsd2si 0x80(%rsp), %esi
cvttsd2si 0x78(%rsp), %edx
movsd 0x88(%rsp), %xmm0
movl $0x16, %edi
leaq 0x110(%rsp), %rcx
leaq 0xf0(%rsp), %r8
leaq 0x90(%rsp), %r9
movq %r9, 0x8(%rsp)
callq 0x6c00
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movsd 0x80(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x5a, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x138, %rsp            # imm = 0x138
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_gemm_rm_notransp
void test_gemm_rm_notransp() {
  double a[] = {1, 2, 3,
                4, 5, 6};
  double b[] = {7, 10, 13, 16,
                8, 11, 14, 17,
                9, 12, 15, 18};
  double c[] = {10, 20, 30, 40,
                50, 60, 70, 80};
  int m = 2;
  int n = 4;
  int k = 3;
  double alpha = 1;
  double beta = -1;

  double expected_c[] = {40, 48, 56, 64,
                         72, 107, 142, 177};
  morpheus_dgemm(morpheus_row_major, morpheus_no_trans, morpheus_no_trans,
                 m, n, k, alpha, a, b, beta, c);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_c, c, m*n);
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
leaq 0x120(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1040
movsd 0x81dd(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x120(%rsp)
movsd 0x81c4(%rip), %xmm0     # 0xb5b8
movsd %xmm0, 0x128(%rsp)
movsd 0x7d9b(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0x130(%rsp)
movsd 0x889a(%rip), %xmm0     # 0xbcb0
movsd %xmm0, 0x138(%rsp)
movsd 0x8871(%rip), %xmm0     # 0xbc98
movsd %xmm0, 0x140(%rsp)
movsd 0x8870(%rip), %xmm0     # 0xbca8
movsd %xmm0, 0x148(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x8cc0(%rip), %rsi      # 0xc110
movl $0x60, %edx
callq 0x1150
leaq 0x80(%rsp), %rdi
leaq 0x8d07(%rip), %rsi      # 0xc170
movl $0x40, %edx
callq 0x1150
movl $0x2, 0x7c(%rsp)
movl $0x4, 0x78(%rsp)
movl $0x3, 0x74(%rsp)
movsd 0x812d(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x68(%rsp)
movsd 0x87ff(%rip), %xmm0     # 0xbca0
movsd %xmm0, 0x60(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x8cfd(%rip), %rsi      # 0xc1b0
movl $0x40, %edx
callq 0x1150
movl 0x7c(%rsp), %ecx
movl 0x78(%rsp), %r8d
movl 0x74(%rsp), %r9d
movsd 0x68(%rsp), %xmm0
leaq 0x120(%rsp), %r11
leaq 0xc0(%rsp), %r10
movsd 0x60(%rsp), %xmm1
leaq 0x80(%rsp), %rax
movl $0x15, %edi
movl $0xb, %edx
movl %edx, %esi
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x6ca0
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movl 0x7c(%rsp), %edx
imull 0x78(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x6f, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x158, %rsp            # imm = 0x158
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_gemm_cm_notransp
void test_gemm_cm_notransp() {
  double a[] = {-2, -8,
                -4, -10,
                -6, -12};
  double b[] = {7, 8, 9,
                10, 11, 12,
                13, 14, 15,
                16, 17, 18};
  double c[] = {10, 50,
                20, 60,
                30, 70,
                40, 80};
  int m = 2;
  int n = 4;
  int k = 3;
  double alpha = -0.5;
  double beta = -1;

  double expected_c[] = {40, 72,
                         48, 107,
                         56, 142,
                         64, 177};
  morpheus_dgemm(morpheus_col_major, morpheus_no_trans, morpheus_no_trans,
                 m, n, k, alpha, a, b, beta, c);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_c, c, m*n);
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
leaq 0x120(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1040
movsd 0x8775(%rip), %xmm0     # 0xbce8
movsd %xmm0, 0x120(%rsp)
movsd 0x875c(%rip), %xmm0     # 0xbce0
movsd %xmm0, 0x128(%rsp)
movsd 0x8743(%rip), %xmm0     # 0xbcd8
movsd %xmm0, 0x130(%rsp)
movsd 0x872a(%rip), %xmm0     # 0xbcd0
movsd %xmm0, 0x138(%rsp)
movsd 0x8711(%rip), %xmm0     # 0xbcc8
movsd %xmm0, 0x140(%rsp)
movsd 0x86f8(%rip), %xmm0     # 0xbcc0
movsd %xmm0, 0x148(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x8c10(%rip), %rsi      # 0xc1f0
movl $0x60, %edx
callq 0x1150
leaq 0x80(%rsp), %rdi
leaq 0x8c57(%rip), %rsi      # 0xc250
movl $0x40, %edx
callq 0x1150
movl $0x2, 0x7c(%rsp)
movl $0x4, 0x78(%rsp)
movl $0x3, 0x74(%rsp)
movsd 0x8695(%rip), %xmm0     # 0xbcb8
movsd %xmm0, 0x68(%rsp)
movsd 0x866f(%rip), %xmm0     # 0xbca0
movsd %xmm0, 0x60(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x8c4d(%rip), %rsi      # 0xc290
movl $0x40, %edx
callq 0x1150
movl 0x7c(%rsp), %ecx
movl 0x78(%rsp), %r8d
movl 0x74(%rsp), %r9d
movsd 0x68(%rsp), %xmm0
leaq 0x120(%rsp), %r11
leaq 0xc0(%rsp), %r10
movsd 0x60(%rsp), %xmm1
leaq 0x80(%rsp), %rax
movl $0x16, %edi
movl $0xb, %edx
movl %edx, %esi
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x6ca0
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movl 0x7c(%rsp), %edx
imull 0x78(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x8a, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x158, %rsp            # imm = 0x158
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_gemm_rm_transp
void test_gemm_rm_transp() {
  double a[] = {1, 4,
                2, 5,
                3, 6};
  double b[] = {7, 8, 9,
                10, 11, 12,
                13, 14, 15,
                16, 17, 18};
  double c[] = {10, 20, 30, 40,
                50, 60, 70, 80};
  int m = 2;
  int n = 4;
  int k = 3;
  double alpha = 1;
  double beta = -1;

  double expected_c[] = {40, 48, 56, 64,
                         72, 107, 142, 177};
  morpheus_dgemm(morpheus_row_major, morpheus_trans, morpheus_trans,
                 m, n, k, alpha, a, b, beta, c);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_c, c, m*n);
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
leaq 0x120(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1040
movsd 0x7ebd(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x120(%rsp)
movsd 0x859c(%rip), %xmm0     # 0xbcb0
movsd %xmm0, 0x128(%rsp)
movsd 0x7e93(%rip), %xmm0     # 0xb5b8
movsd %xmm0, 0x130(%rsp)
movsd 0x8562(%rip), %xmm0     # 0xbc98
movsd %xmm0, 0x138(%rsp)
movsd 0x7a59(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0x140(%rsp)
movsd 0x8550(%rip), %xmm0     # 0xbca8
movsd %xmm0, 0x148(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x8b60(%rip), %rsi      # 0xc2d0
movl $0x60, %edx
callq 0x1150
leaq 0x80(%rsp), %rdi
leaq 0x8ba7(%rip), %rsi      # 0xc330
movl $0x40, %edx
callq 0x1150
movl $0x2, 0x7c(%rsp)
movl $0x4, 0x78(%rsp)
movl $0x3, 0x74(%rsp)
movsd 0x7e0d(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x68(%rsp)
movsd 0x84df(%rip), %xmm0     # 0xbca0
movsd %xmm0, 0x60(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x8b9d(%rip), %rsi      # 0xc370
movl $0x40, %edx
callq 0x1150
movl 0x7c(%rsp), %ecx
movl 0x78(%rsp), %r8d
movl 0x74(%rsp), %r9d
movsd 0x68(%rsp), %xmm0
leaq 0x120(%rsp), %r11
leaq 0xc0(%rsp), %r10
movsd 0x60(%rsp), %xmm1
leaq 0x80(%rsp), %rax
movl $0x15, %edi
movl $0xc, %edx
movl %edx, %esi
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x6ca0
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movl 0x7c(%rsp), %edx
imull 0x78(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0xa1, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x158, %rsp            # imm = 0x158
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_gemm_cm_transp
void test_gemm_cm_transp() {
  double a[] = {1, 2, 3,
                4, 5, 6};
  double b[] = {7, 8, 9,
                10, 11, 12,
                13, 14, 15,
                16, 17, 18};
  double c[] = {1, 5,
                2, 6,
                3, 7,
                4, 8};
  int m = 2;
  int n = 4;
  int k = 3;
  double alpha = 1;
  double beta = -10;

  double expected_c[] = {40, 72,
                         48, 107,
                         56, 142,
                         64, 177};
  morpheus_dgemm(morpheus_col_major, morpheus_trans, morpheus_no_trans,
                 m, n, k, alpha, a, b, beta, c);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_c, c, m*n);
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
leaq 0x120(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1040
movsd 0x7d2d(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x120(%rsp)
movsd 0x7d14(%rip), %xmm0     # 0xb5b8
movsd %xmm0, 0x128(%rsp)
movsd 0x78eb(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0x130(%rsp)
movsd 0x83ea(%rip), %xmm0     # 0xbcb0
movsd %xmm0, 0x138(%rsp)
movsd 0x83c1(%rip), %xmm0     # 0xbc98
movsd %xmm0, 0x140(%rsp)
movsd 0x83c0(%rip), %xmm0     # 0xbca8
movsd %xmm0, 0x148(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x8ab0(%rip), %rsi      # 0xc3b0
movl $0x60, %edx
callq 0x1150
leaq 0x80(%rsp), %rdi
leaq 0x8af7(%rip), %rsi      # 0xc410
movl $0x40, %edx
callq 0x1150
movl $0x2, 0x7c(%rsp)
movl $0x4, 0x78(%rsp)
movl $0x3, 0x74(%rsp)
movsd 0x7c7d(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x68(%rsp)
movsd 0x837f(%rip), %xmm0     # 0xbcd0
movsd %xmm0, 0x60(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x8aed(%rip), %rsi      # 0xc450
movl $0x40, %edx
callq 0x1150
movl 0x7c(%rsp), %ecx
movl 0x78(%rsp), %r8d
movl 0x74(%rsp), %r9d
movsd 0x68(%rsp), %xmm0
leaq 0x120(%rsp), %r11
leaq 0xc0(%rsp), %r10
movsd 0x60(%rsp), %xmm1
leaq 0x80(%rsp), %rax
movl $0x16, %edi
movl $0xc, %esi
movl $0xb, %edx
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x6ca0
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movl 0x7c(%rsp), %edx
imull 0x78(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0xbb, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x158, %rsp            # imm = 0x158
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_gemv_rm_notransp
void test_gemv_rm_notransp() {
  double a[] = {1, 2, 3,
                4, 5, 6};
  double x[] = {-14, -16, -18};
  double y[] = {2, 4};
  int nrows = 2;
  int ncols = 3;
  double alpha = -0.5;
  double beta = -5;

  double expected_y[] = {40, 102};
  morpheus_dgemv(morpheus_row_major, morpheus_no_trans, nrows, ncols,
                 alpha, a, x, beta, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y, y, nrows);
}

// Assembly:
subq $0xa8, %rsp
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1040
movsd 0x7ba0(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x70(%rsp)
movsd 0x7b8a(%rip), %xmm0     # 0xb5b8
movsd %xmm0, 0x78(%rsp)
movsd 0x7764(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0x80(%rsp)
movsd 0x8263(%rip), %xmm0     # 0xbcb0
movsd %xmm0, 0x88(%rsp)
movsd 0x823a(%rip), %xmm0     # 0xbc98
movsd %xmm0, 0x90(%rsp)
movsd 0x8239(%rip), %xmm0     # 0xbca8
movsd %xmm0, 0x98(%rsp)
movq 0x8a11(%rip), %rax      # 0xc490
movq %rax, 0x50(%rsp)
movq 0x8a0d(%rip), %rax      # 0xc498
movq %rax, 0x58(%rsp)
movq 0x8a09(%rip), %rax      # 0xc4a0
movq %rax, 0x60(%rsp)
movq 0x8ecd(%rip), %rax      # 0xc970
movq %rax, 0x40(%rsp)
movq 0x8ec9(%rip), %rax      # 0xc978
movq %rax, 0x48(%rsp)
movl $0x2, 0x3c(%rsp)
movl $0x3, 0x38(%rsp)
movsd 0x81ec(%rip), %xmm0     # 0xbcb8
movsd %xmm0, 0x30(%rsp)
movsd 0x8216(%rip), %xmm0     # 0xbcf0
movsd %xmm0, 0x28(%rsp)
movq 0x8e99(%rip), %rax      # 0xc980
movq %rax, 0x10(%rsp)
movq 0x8e95(%rip), %rax      # 0xc988
movq %rax, 0x18(%rsp)
movl 0x3c(%rsp), %edx
movl 0x38(%rsp), %ecx
movsd 0x30(%rsp), %xmm0
leaq 0x70(%rsp), %r8
leaq 0x50(%rsp), %r9
movsd 0x28(%rsp), %xmm1
leaq 0x40(%rsp), %rax
movl $0x15, %edi
movl $0xb, %esi
movq %rax, (%rsp)
callq 0x69d0
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl 0x3c(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0xcb, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0xa8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_gemv_cm_notransp
void test_gemv_cm_notransp() {
  double a[] = {1, 4,
                2, 5,
                3, 6};
  double x[] = {-14, -16, -18};
  double y[] = {2, 4};
  int nrows = 2;
  int ncols = 3;
  double alpha = -0.5;
  double beta = -5;

  double expected_y[] = {40, 102};
  morpheus_dgemv(morpheus_col_major, morpheus_no_trans, nrows, ncols,
                 alpha, a, x, beta, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y, y, nrows);
}

// Assembly:
subq $0xa8, %rsp
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1040
movsd 0x7a40(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x70(%rsp)
movsd 0x8122(%rip), %xmm0     # 0xbcb0
movsd %xmm0, 0x78(%rsp)
movsd 0x7a1c(%rip), %xmm0     # 0xb5b8
movsd %xmm0, 0x80(%rsp)
movsd 0x80eb(%rip), %xmm0     # 0xbc98
movsd %xmm0, 0x88(%rsp)
movsd 0x75e2(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0x90(%rsp)
movsd 0x80d9(%rip), %xmm0     # 0xbca8
movsd %xmm0, 0x98(%rsp)
movq 0x88d1(%rip), %rax      # 0xc4b0
movq %rax, 0x50(%rsp)
movq 0x88cd(%rip), %rax      # 0xc4b8
movq %rax, 0x58(%rsp)
movq 0x88c9(%rip), %rax      # 0xc4c0
movq %rax, 0x60(%rsp)
movq 0x8d6d(%rip), %rax      # 0xc970
movq %rax, 0x40(%rsp)
movq 0x8d69(%rip), %rax      # 0xc978
movq %rax, 0x48(%rsp)
movl $0x2, 0x3c(%rsp)
movl $0x3, 0x38(%rsp)
movsd 0x808c(%rip), %xmm0     # 0xbcb8
movsd %xmm0, 0x30(%rsp)
movsd 0x80b6(%rip), %xmm0     # 0xbcf0
movsd %xmm0, 0x28(%rsp)
movq 0x8d39(%rip), %rax      # 0xc980
movq %rax, 0x10(%rsp)
movq 0x8d35(%rip), %rax      # 0xc988
movq %rax, 0x18(%rsp)
movl 0x3c(%rsp), %edx
movl 0x38(%rsp), %ecx
movsd 0x30(%rsp), %xmm0
leaq 0x70(%rsp), %r8
leaq 0x50(%rsp), %r9
movsd 0x28(%rsp), %xmm1
leaq 0x40(%rsp), %rax
movl $0x16, %edi
movl $0xb, %esi
movq %rax, (%rsp)
callq 0x69d0
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl 0x3c(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0xdc, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0xa8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_gemv_rm_transp
void test_gemv_rm_transp() {
  double a[] = {1, 4,
                2, 5,
                3, 6};
  double x[] = {-14, -16, -18};
  double y[] = {2, 4};
  int nrows = 3;
  int ncols = 2;
  double alpha = -0.5;
  double beta = -5;

  double expected_y[] = {40, 102};
  morpheus_dgemv(morpheus_row_major, morpheus_trans, nrows, ncols,
                 alpha, a, x, beta, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y, y, ncols);
}

// Assembly:
subq $0xa8, %rsp
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1040
movsd 0x78e0(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x70(%rsp)
movsd 0x7fc2(%rip), %xmm0     # 0xbcb0
movsd %xmm0, 0x78(%rsp)
movsd 0x78bc(%rip), %xmm0     # 0xb5b8
movsd %xmm0, 0x80(%rsp)
movsd 0x7f8b(%rip), %xmm0     # 0xbc98
movsd %xmm0, 0x88(%rsp)
movsd 0x7482(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0x90(%rsp)
movsd 0x7f79(%rip), %xmm0     # 0xbca8
movsd %xmm0, 0x98(%rsp)
movq 0x8791(%rip), %rax      # 0xc4d0
movq %rax, 0x50(%rsp)
movq 0x878d(%rip), %rax      # 0xc4d8
movq %rax, 0x58(%rsp)
movq 0x8789(%rip), %rax      # 0xc4e0
movq %rax, 0x60(%rsp)
movq 0x8c0d(%rip), %rax      # 0xc970
movq %rax, 0x40(%rsp)
movq 0x8c09(%rip), %rax      # 0xc978
movq %rax, 0x48(%rsp)
movl $0x3, 0x3c(%rsp)
movl $0x2, 0x38(%rsp)
movsd 0x7f2c(%rip), %xmm0     # 0xbcb8
movsd %xmm0, 0x30(%rsp)
movsd 0x7f56(%rip), %xmm0     # 0xbcf0
movsd %xmm0, 0x28(%rsp)
movq 0x8bd9(%rip), %rax      # 0xc980
movq %rax, 0x10(%rsp)
movq 0x8bd5(%rip), %rax      # 0xc988
movq %rax, 0x18(%rsp)
movl 0x3c(%rsp), %edx
movl 0x38(%rsp), %ecx
movsd 0x30(%rsp), %xmm0
leaq 0x70(%rsp), %r8
leaq 0x50(%rsp), %r9
movsd 0x28(%rsp), %xmm1
leaq 0x40(%rsp), %rax
movl $0x15, %edi
movl $0xc, %esi
movq %rax, (%rsp)
callq 0x69d0
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl 0x38(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0xed, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0xa8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_gemv_cm_transp
void test_gemv_cm_transp() {
  double a[] = {1, 2, 3,
                4, 5, 6};
  double x[] = {-14, -16, -18};
  double y[] = {2, 4};
  int nrows = 3;
  int ncols = 2;
  double alpha = -0.5;
  double beta = -5;

  double expected_y[] = {40, 102};
  morpheus_dgemv(morpheus_col_major, morpheus_trans, nrows, ncols,
                 alpha, a, x, beta, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y, y, ncols);
}

// Assembly:
subq $0xa8, %rsp
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1040
movsd 0x7780(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x70(%rsp)
movsd 0x776a(%rip), %xmm0     # 0xb5b8
movsd %xmm0, 0x78(%rsp)
movsd 0x7344(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0x80(%rsp)
movsd 0x7e43(%rip), %xmm0     # 0xbcb0
movsd %xmm0, 0x88(%rsp)
movsd 0x7e1a(%rip), %xmm0     # 0xbc98
movsd %xmm0, 0x90(%rsp)
movsd 0x7e19(%rip), %xmm0     # 0xbca8
movsd %xmm0, 0x98(%rsp)
movq 0x8651(%rip), %rax      # 0xc4f0
movq %rax, 0x50(%rsp)
movq 0x864d(%rip), %rax      # 0xc4f8
movq %rax, 0x58(%rsp)
movq 0x8649(%rip), %rax      # 0xc500
movq %rax, 0x60(%rsp)
movq 0x8aad(%rip), %rax      # 0xc970
movq %rax, 0x40(%rsp)
movq 0x8aa9(%rip), %rax      # 0xc978
movq %rax, 0x48(%rsp)
movl $0x3, 0x3c(%rsp)
movl $0x2, 0x38(%rsp)
movsd 0x7dcc(%rip), %xmm0     # 0xbcb8
movsd %xmm0, 0x30(%rsp)
movsd 0x7df6(%rip), %xmm0     # 0xbcf0
movsd %xmm0, 0x28(%rsp)
movq 0x8a79(%rip), %rax      # 0xc980
movq %rax, 0x10(%rsp)
movq 0x8a75(%rip), %rax      # 0xc988
movq %rax, 0x18(%rsp)
movl 0x3c(%rsp), %edx
movl 0x38(%rsp), %ecx
movsd 0x30(%rsp), %xmm0
leaq 0x70(%rsp), %r8
leaq 0x50(%rsp), %r9
movsd 0x28(%rsp), %xmm1
leaq 0x40(%rsp), %rax
movl $0x16, %edi
movl $0xc, %esi
movq %rax, (%rsp)
callq 0x69d0
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl 0x38(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0xfd, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0xa8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_dcopy
void test_dcopy() {
  double x[] = {11, -2, 13, -4, 15, -6};
  double y[6];
  int n = 6;
  morpheus_dcopy(n, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(x, y, n);
}

// Assembly:
subq $0x78, %rsp
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1040
movsd 0x71fb(%rip), %xmm0     # 0xb198
movsd %xmm0, 0x40(%rsp)
movsd 0x7d3d(%rip), %xmm0     # 0xbce8
movsd %xmm0, 0x48(%rsp)
movsd 0x71f7(%rip), %xmm0     # 0xb1b0
movsd %xmm0, 0x50(%rsp)
movsd 0x7d11(%rip), %xmm0     # 0xbcd8
movsd %xmm0, 0x58(%rsp)
movsd 0x7d23(%rip), %xmm0     # 0xbcf8
movsd %xmm0, 0x60(%rsp)
movsd 0x7ce5(%rip), %xmm0     # 0xbcc8
movsd %xmm0, 0x68(%rsp)
movl $0x6, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x6950
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x105, %r8d            # imm = 0x105
movl $0x1, %r9d
callq 0x8ec0
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_dcopy_scalar
void test_dcopy_scalar() {
  double alpha = 11;
  double x[6];
  int n = 6;

  morpheus_dcopy_scalar(n, alpha, x);
  TEST_ASSERT_EACH_EQUAL_DOUBLE(alpha, x, n);
}

// Assembly:
subq $0x48, %rsp
movsd 0x715c(%rip), %xmm0     # 0xb198
movsd %xmm0, 0x40(%rsp)
movl $0x6, 0xc(%rsp)
movl 0xc(%rsp), %edi
movsd 0x40(%rsp), %xmm0
leaq 0x10(%rsp), %rsi
callq 0x6990
movsd 0x40(%rsp), %xmm0
callq 0xa140
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x10e, %r8d            # imm = 0x10E
xorl %r9d, %r9d
callq 0x8ec0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_ddot
void test_ddot() {
  double x[] = {7, 13, 11, 19, 17};
  double y[] = {3, 17, 21, 29, 33};
  int n = sizeof(x)/sizeof(x[0]);

  double expected = 7*3 + 13*17 + 11*21 + 19*29 + 17*33;
  TEST_ASSERT_EQUAL_DOUBLE(expected, morpheus_ddot(n, x, y));
}

// Assembly:
subq $0x78, %rsp
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x7503(%rip), %xmm0     # 0xb5b0
movsd %xmm0, 0x50(%rsp)
movsd 0x70f5(%rip), %xmm0     # 0xb1b0
movsd %xmm0, 0x58(%rsp)
movsd 0x70cf(%rip), %xmm0     # 0xb198
movsd %xmm0, 0x60(%rsp)
movsd 0x7c51(%rip), %xmm0     # 0xbd28
movsd %xmm0, 0x68(%rsp)
movsd 0x7c3b(%rip), %xmm0     # 0xbd20
movsd %xmm0, 0x70(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x709c(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0x20(%rsp)
movsd 0x7c0e(%rip), %xmm0     # 0xbd20
movsd %xmm0, 0x28(%rsp)
movsd 0x7bf8(%rip), %xmm0     # 0xbd18
movsd %xmm0, 0x30(%rsp)
movsd 0x7be2(%rip), %xmm0     # 0xbd10
movsd %xmm0, 0x38(%rsp)
movsd 0x7bcc(%rip), %xmm0     # 0xbd08
movsd %xmm0, 0x40(%rsp)
movl $0x5, 0x1c(%rsp)
movsd 0x7bae(%rip), %xmm0     # 0xbd00
movsd %xmm0, 0x10(%rsp)
movsd 0x7ac0(%rip), %xmm0     # 0xbc20
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rsp)
movl 0x1c(%rsp), %edi
leaq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x6b10
movsd (%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
xorl %eax, %eax
movl %eax, %edi
movl $0x117, %esi            # imm = 0x117
callq 0x92c0
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_dnrm2
void test_dnrm2() {
  double x[] = {-1, -5, 7, 11, 1, -3, -9, 10, 5, -6, -9};
  int n = sizeof(x)/sizeof(x[0]);

  double expected = 23;
  TEST_ASSERT_EQUAL_DOUBLE(expected, morpheus_dnrm2(n, x));
}

// Assembly:
subq $0x78, %rsp
leaq 0x20(%rsp), %rdi
leaq 0x8350(%rip), %rsi      # 0xc510
movl $0x58, %edx
callq 0x1150
movl $0xb, 0x1c(%rsp)
movsd 0x6fce(%rip), %xmm0     # 0xb1a8
movsd %xmm0, 0x10(%rsp)
movsd 0x7a38(%rip), %xmm0     # 0xbc20
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rsp)
movl 0x1c(%rsp), %edi
leaq 0x20(%rsp), %rsi
callq 0x6ae0
movsd (%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
xorl %eax, %eax
movl %eax, %edi
movl $0x11f, %esi            # imm = 0x11F
callq 0x92c0
addq $0x78, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_dscal
void test_dscal() {
  double x[] = {1, 2, 3, 4, 5};
  double alpha = 3;
  double expected_x[] = {3, 6, 9, 12, 15};
  int n = sizeof(x)/sizeof(x[0]);

  morpheus_dscal(n, alpha, x);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_x, x, n);
}

// Assembly:
subq $0x68, %rsp
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x7373(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x40(%rsp)
movsd 0x735d(%rip), %xmm0     # 0xb5b8
movsd %xmm0, 0x48(%rsp)
movsd 0x6f37(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0x50(%rsp)
movsd 0x7a39(%rip), %xmm0     # 0xbcb0
movsd %xmm0, 0x58(%rsp)
movsd 0x7a13(%rip), %xmm0     # 0xbc98
movsd %xmm0, 0x60(%rsp)
movsd 0x6f0d(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0x38(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1040
movsd 0x6eee(%rip), %xmm0     # 0xb1a0
movsd %xmm0, 0x10(%rsp)
movsd 0x79e8(%rip), %xmm0     # 0xbca8
movsd %xmm0, 0x18(%rsp)
movsd 0x6eea(%rip), %xmm0     # 0xb1b8
movsd %xmm0, 0x20(%rsp)
movsd 0x7a54(%rip), %xmm0     # 0xbd30
movsd %xmm0, 0x28(%rsp)
movsd 0x7a0e(%rip), %xmm0     # 0xbcf8
movsd %xmm0, 0x30(%rsp)
movl $0x5, 0xc(%rsp)
movl 0xc(%rsp), %edi
movsd 0x38(%rsp), %xmm0
leaq 0x40(%rsp), %rsi
callq 0x6910
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl 0xc(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x129, %r8d            # imm = 0x129
movl $0x1, %r9d
callq 0x8ec0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_daxpy
void test_daxpy() {
  double x[] = {1, 2, 3, 4, 5, 6, 7};
  double y[] = {-1, 1, -1, 1, -1, 1, -1};
  double alpha = -1;
  int n = sizeof(x)/sizeof(x[0]);

  double expected_y[] = {-2, -1, -4, -3, -6, -5, -8};
  morpheus_daxpy(n, alpha, x, y);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_y, y, n);
}

// Assembly:
subq $0xc8, %rsp
leaq 0x90(%rsp), %rdi
leaq 0x821a(%rip), %rsi      # 0xc570
movl $0x38, %edx
callq 0x1150
leaq 0x50(%rsp), %rdi
leaq 0x8244(%rip), %rsi      # 0xc5b0
movl $0x38, %edx
callq 0x1150
movsd 0x7922(%rip), %xmm0     # 0xbca0
movsd %xmm0, 0x48(%rsp)
movl $0x7, 0x44(%rsp)
movq %rsp, %rdi
leaq 0x825a(%rip), %rsi      # 0xc5f0
movl $0x38, %edx
callq 0x1150
movl 0x44(%rsp), %edi
movsd 0x48(%rsp), %xmm0
leaq 0x90(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x6a90
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
movl 0x44(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x134, %r8d            # imm = 0x134
movl $0x1, %r9d
callq 0x8ec0
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/simple_blas_test.c
// Function: test_identity
void test_identity() {
  int n = 7;
  double identity[100];
  double expected[100] = {1, 0, 0, 0, 0, 0, 0,
                       0, 1, 0, 0, 0, 0, 0,
                       0, 0, 1, 0, 0, 0, 0,
                       0, 0, 0, 1, 0, 0, 0,
                       0, 0, 0, 0, 1, 0, 0,
                       0, 0, 0, 0, 0, 1, 0,
                       0, 0, 0, 0, 0, 0, 1};
  for (int i = 49; i < 100; ++i) {
    identity[i] = expected[i] = 100+i; // guard values
  }

  morpheus_identity(n, identity);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, identity, 100);
}

// Assembly:
subq $0x658, %rsp            # imm = 0x658
movl $0x7, 0x654(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8222(%rip), %rsi      # 0xc630
movl $0x320, %edx            # imm = 0x320
callq 0x1150
movl $0x31, 0xc(%rsp)
cmpl $0x64, 0xc(%rsp)
jge 0x4458
movl 0xc(%rsp), %eax
addl $0x64, %eax
cvtsi2sd %eax, %xmm0
movslq 0xc(%rsp), %rax
movsd %xmm0, 0x10(%rsp,%rax,8)
movslq 0xc(%rsp), %rax
movsd %xmm0, 0x330(%rsp,%rax,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4420
movl 0x654(%rsp), %edi
leaq 0x330(%rsp), %rsi
callq 0x6e20
leaq 0x10(%rsp), %rdi
leaq 0x330(%rsp), %rsi
movl $0x64, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x146, %r8d            # imm = 0x146
movl $0x1, %r9d
callq 0x8ec0
addq $0x658, %rsp            # imm = 0x658
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/statistics_test.c
// Function: test_mean
void test_mean() {
  double x[] = {35,32,213,54,81,92,63,70};
  int n = sizeof(x)/sizeof(x[0]);

  double m = morpheus_mean(n, x);
  TEST_ASSERT_EQUAL_DOUBLE(80, m);
}

// Assembly:
subq $0x58, %rsp
leaq 0x10(%rsp), %rdi
leaq 0x8500(%rip), %rsi      # 0xc9b0
movl $0x40, %edx
callq 0x1150
movl $0x8, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x10(%rsp), %rsi
callq 0x6e90
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm2
movsd 0x84ae(%rip), %xmm0     # 0xc990
movsd 0x84ae(%rip), %xmm1     # 0xc998
xorl %eax, %eax
movl %eax, %edi
movl $0x9, %esi
callq 0x92c0
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/statistics_test.c
// Function: test_stddev_m
void test_stddev_m() {
  double x[] = {35,32,213,54,81,92,63,70};
  int n = sizeof(x)/sizeof(x[0]);
  double m = 80;

  double s = morpheus_stddev_m(m, n, x);
  TEST_ASSERT_EQUAL_DOUBLE(57.60456, s);
}

// Assembly:
subq $0x68, %rsp
leaq 0x20(%rsp), %rdi
leaq 0x84e0(%rip), %rsi      # 0xc9f0
movl $0x40, %edx
callq 0x1150
movl $0x8, 0x1c(%rsp)
movsd 0x846e(%rip), %xmm0     # 0xc998
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movl 0x1c(%rsp), %edi
leaq 0x20(%rsp), %rsi
callq 0x6ef0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm2
movsd 0x8448(%rip), %xmm0     # 0xc9a0
movsd 0x8448(%rip), %xmm1     # 0xc9a8
xorl %eax, %eax
movl %eax, %edi
movl $0x12, %esi
callq 0x92c0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/statistics_test.c
// Function: test_stddev
void test_stddev() {
  double x[] = {35,32,213,54,81,92,63,70};
  int n = sizeof(x)/sizeof(x[0]);

  double s = morpheus_stddev(n, x);
  TEST_ASSERT_EQUAL_DOUBLE(57.60456, s);
}

// Assembly:
subq $0x58, %rsp
leaq 0x10(%rsp), %rdi
leaq 0x84a0(%rip), %rsi      # 0xca30
movl $0x40, %edx
callq 0x1150
movl $0x8, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x10(%rsp), %rsi
callq 0x6fb0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm2
movsd 0x83de(%rip), %xmm0     # 0xc9a0
movsd 0x83de(%rip), %xmm1     # 0xc9a8
xorl %eax, %eax
movl %eax, %edi
movl $0x1a, %esi
callq 0x92c0
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/statistics_test.c
// Function: test_column_mean
void test_column_mean() {
  double a[] = {35,32,213,54,
                81,92,63,70,
                77,14,91,20};
  int m = 3;
  int n = 4;

  double expected_means_rm[] = {64.33333, 46, 122.33333, 48};
  double expected_stddev_rm[] = {25.48202, 40.84116, 79.75797, 25.53429};

  double expected_means_cm[] = {83.5, 76.5, 50.5};
  double expected_stddev_cm[] = {86.88114, 12.71482, 39.17908};

  double means[4];

  morpheus_column_mean(morpheus_row_major, m, n, a, means);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_means_rm, means, n);

  morpheus_column_mean(morpheus_col_major, n, m, a, means);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_means_cm, means, m);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
leaq 0xb0(%rsp), %rdi
leaq 0x847a(%rip), %rsi      # 0xca70
movl $0x60, %edx
callq 0x1150
movl $0x3, 0xac(%rsp)
movl $0x4, 0xa8(%rsp)
movq 0x86b3(%rip), %rax      # 0xccd0
movq %rax, 0x80(%rsp)
movq 0x86ac(%rip), %rax      # 0xccd8
movq %rax, 0x88(%rsp)
movq 0x86a5(%rip), %rax      # 0xcce0
movq %rax, 0x90(%rsp)
movq 0x869e(%rip), %rax      # 0xcce8
movq %rax, 0x98(%rsp)
movq 0x8697(%rip), %rax      # 0xccf0
movq %rax, 0x60(%rsp)
movq 0x8693(%rip), %rax      # 0xccf8
movq %rax, 0x68(%rsp)
movq 0x868f(%rip), %rax      # 0xcd00
movq %rax, 0x70(%rsp)
movq 0x868b(%rip), %rax      # 0xcd08
movq %rax, 0x78(%rsp)
movq 0x8447(%rip), %rax      # 0xcad0
movq %rax, 0x40(%rsp)
movq 0x8443(%rip), %rax      # 0xcad8
movq %rax, 0x48(%rsp)
movq 0x843f(%rip), %rax      # 0xcae0
movq %rax, 0x50(%rsp)
movq 0x8443(%rip), %rax      # 0xcaf0
movq %rax, 0x20(%rsp)
movq 0x843f(%rip), %rax      # 0xcaf8
movq %rax, 0x28(%rsp)
movq 0x843b(%rip), %rax      # 0xcb00
movq %rax, 0x30(%rsp)
movl 0xac(%rsp), %esi
movl 0xa8(%rsp), %edx
leaq 0xb0(%rsp), %rcx
movq %rsp, %r8
movl $0x15, %edi
callq 0x7010
leaq 0x80(%rsp), %rdi
movq %rsp, %rsi
movl 0xa8(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x2d, %r8d
movl $0x1, %r9d
callq 0x8ec0
movl 0xa8(%rsp), %esi
movl 0xac(%rsp), %edx
leaq 0xb0(%rsp), %rcx
movq %rsp, %r8
movl $0x16, %edi
callq 0x7010
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
movl 0xac(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x30, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x118, %rsp            # imm = 0x118
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/statistics_test.c
// Function: test_row_mean
void test_row_mean() {
  double a[] = {35,32,213,54,
                81,92,63,70,
                77,14,91,20};
  int m = 3;
  int n = 4;

  double expected_means_rm[] = {83.5, 76.5, 50.5};
  double expected_means_cm[] = {64.33333, 46, 122.33333, 48};

  double means[4];

  morpheus_row_mean(morpheus_row_major, m, n, a, means);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_means_rm, means, m);

  morpheus_row_mean(morpheus_col_major, n, m, a, means);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_means_cm, means, n);
}

// Assembly:
subq $0xc8, %rsp
leaq 0x60(%rsp), %rdi
leaq 0x838d(%rip), %rsi      # 0xcb10
movl $0x60, %edx
callq 0x1150
movl $0x3, 0x5c(%rsp)
movl $0x4, 0x58(%rsp)
movq 0x83cc(%rip), %rax      # 0xcb70
movq %rax, 0x40(%rsp)
movq 0x83c8(%rip), %rax      # 0xcb78
movq %rax, 0x48(%rsp)
movq 0x83c4(%rip), %rax      # 0xcb80
movq %rax, 0x50(%rsp)
movq 0x8508(%rip), %rax      # 0xccd0
movq %rax, 0x20(%rsp)
movq 0x8504(%rip), %rax      # 0xccd8
movq %rax, 0x28(%rsp)
movq 0x8500(%rip), %rax      # 0xcce0
movq %rax, 0x30(%rsp)
movq 0x84fc(%rip), %rax      # 0xcce8
movq %rax, 0x38(%rsp)
movl 0x5c(%rsp), %esi
movl 0x58(%rsp), %edx
leaq 0x60(%rsp), %rcx
movq %rsp, %r8
movl $0x15, %edi
callq 0x7090
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
movl 0x5c(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x40, %r8d
movl $0x1, %r9d
callq 0x8ec0
movl 0x58(%rsp), %esi
movl 0x5c(%rsp), %edx
leaq 0x60(%rsp), %rcx
movq %rsp, %r8
movl $0x16, %edi
callq 0x7090
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl 0x58(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x43, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0xc8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/statistics_test.c
// Function: test_column_stddev_m
void test_column_stddev_m() {
  double a[] = {35,32,213,54,
                81,92,63,70,
                77,14,91,20};
  int m = 3;
  int n = 4;

  double means_rm[] = {64.33333, 46, 122.33333, 48};
  double expected_stddev_rm[] = {25.48202, 40.84116, 79.75797, 25.53429};

  double means_cm[] = {83.5, 76.5, 50.5};
  double expected_stddev_cm[] = {86.88114, 12.71482, 39.17908};

  double stddevs[4];

  morpheus_column_stddev_m(morpheus_row_major, m, n, means_rm, a, stddevs);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_stddev_rm, stddevs, n);

  morpheus_column_stddev_m(morpheus_col_major, n, m, means_cm, a, stddevs);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_stddev_cm, stddevs, m);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
leaq 0xb0(%rsp), %rdi
leaq 0x830a(%rip), %rsi      # 0xcb90
movl $0x60, %edx
callq 0x1150
movl $0x3, 0xac(%rsp)
movl $0x4, 0xa8(%rsp)
movq 0x8423(%rip), %rax      # 0xccd0
movq %rax, 0x80(%rsp)
movq 0x841c(%rip), %rax      # 0xccd8
movq %rax, 0x88(%rsp)
movq 0x8415(%rip), %rax      # 0xcce0
movq %rax, 0x90(%rsp)
movq 0x840e(%rip), %rax      # 0xcce8
movq %rax, 0x98(%rsp)
movq 0x8407(%rip), %rax      # 0xccf0
movq %rax, 0x60(%rsp)
movq 0x8403(%rip), %rax      # 0xccf8
movq %rax, 0x68(%rsp)
movq 0x83ff(%rip), %rax      # 0xcd00
movq %rax, 0x70(%rsp)
movq 0x83fb(%rip), %rax      # 0xcd08
movq %rax, 0x78(%rsp)
movq 0x82d7(%rip), %rax      # 0xcbf0
movq %rax, 0x40(%rsp)
movq 0x82d3(%rip), %rax      # 0xcbf8
movq %rax, 0x48(%rsp)
movq 0x82cf(%rip), %rax      # 0xcc00
movq %rax, 0x50(%rsp)
movq 0x82d3(%rip), %rax      # 0xcc10
movq %rax, 0x20(%rsp)
movq 0x82cf(%rip), %rax      # 0xcc18
movq %rax, 0x28(%rsp)
movq 0x82cb(%rip), %rax      # 0xcc20
movq %rax, 0x30(%rsp)
movl 0xac(%rsp), %esi
movl 0xa8(%rsp), %edx
leaq 0x80(%rsp), %rcx
leaq 0xb0(%rsp), %r8
movq %rsp, %r9
movl $0x15, %edi
callq 0x7110
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
movl 0xa8(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x56, %r8d
movl $0x1, %r9d
callq 0x8ec0
movl 0xa8(%rsp), %esi
movl 0xac(%rsp), %edx
leaq 0x40(%rsp), %rcx
leaq 0xb0(%rsp), %r8
movq %rsp, %r9
movl $0x16, %edi
callq 0x7110
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl 0xac(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x59, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x118, %rsp            # imm = 0x118
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/statistics_test.c
// Function: test_row_stddev_m
void test_row_stddev_m() {
  double a[] = {35,32,213,54,
                81,92,63,70,
                77,14,91,20};
  int m = 3;
  int n = 4;

  double means_rm[] = {83.5, 76.5, 50.5};
  double expected_stddev_rm[] = {86.88114, 12.71482, 39.17908};

  double means_cm[] = {64.33333, 46, 122.33333, 48};
  double expected_stddev_cm[] = {25.48202, 40.84116, 79.75797, 25.53429};

  double stddevs[4];

  morpheus_row_stddev_m(morpheus_row_major, m, n, means_rm, a, stddevs);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_stddev_rm, stddevs, m);

  morpheus_row_stddev_m(morpheus_col_major, n, m, means_cm, a, stddevs);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_stddev_cm, stddevs, n);
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
leaq 0xa0(%rsp), %rdi
leaq 0x821a(%rip), %rsi      # 0xcc30
movl $0x60, %edx
callq 0x1150
movl $0x3, 0x9c(%rsp)
movl $0x4, 0x98(%rsp)
movq 0x8253(%rip), %rax      # 0xcc90
movq %rax, 0x80(%rsp)
movq 0x824c(%rip), %rax      # 0xcc98
movq %rax, 0x88(%rsp)
movq 0x8245(%rip), %rax      # 0xcca0
movq %rax, 0x90(%rsp)
movq 0x8246(%rip), %rax      # 0xccb0
movq %rax, 0x60(%rsp)
movq 0x8242(%rip), %rax      # 0xccb8
movq %rax, 0x68(%rsp)
movq 0x823e(%rip), %rax      # 0xccc0
movq %rax, 0x70(%rsp)
movq 0x8242(%rip), %rax      # 0xccd0
movq %rax, 0x40(%rsp)
movq 0x823e(%rip), %rax      # 0xccd8
movq %rax, 0x48(%rsp)
movq 0x823a(%rip), %rax      # 0xcce0
movq %rax, 0x50(%rsp)
movq 0x8236(%rip), %rax      # 0xcce8
movq %rax, 0x58(%rsp)
movq 0x8232(%rip), %rax      # 0xccf0
movq %rax, 0x20(%rsp)
movq 0x822e(%rip), %rax      # 0xccf8
movq %rax, 0x28(%rsp)
movq 0x822a(%rip), %rax      # 0xcd00
movq %rax, 0x30(%rsp)
movq 0x8226(%rip), %rax      # 0xcd08
movq %rax, 0x38(%rsp)
movl 0x9c(%rsp), %esi
movl 0x98(%rsp), %edx
leaq 0x80(%rsp), %rcx
leaq 0xa0(%rsp), %r8
movq %rsp, %r9
movl $0x15, %edi
callq 0x7380
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
movl 0x9c(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x6c, %r8d
movl $0x1, %r9d
callq 0x8ec0
movl 0x98(%rsp), %esi
movl 0x9c(%rsp), %edx
leaq 0x40(%rsp), %rcx
leaq 0xa0(%rsp), %r8
movq %rsp, %r9
movl $0x16, %edi
callq 0x7380
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl 0x98(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x6f, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x108, %rsp            # imm = 0x108
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/tests/wolfe_test.c
// Function: test_wolfe
void test_wolfe() {
  double memory_buffer[2];
  morheus_wolfe_params_t params;
  params.f = func;
  params.df = dfunc;
  params.num_variables = 2;
  params.max_iters = 10;
  params.c1 = 0.15;
  params.c2 = 0.3;
  params.memory_buffer = memory_buffer;

  double x[] = {0.6, 0.5};
  double direction[] = {-0.3, -0.4};
  double result[2];
  morpheus_wolfe(&params, x, direction, 0, result);

  double expected_result[] = {0.225, 0};
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected_result, result, 2);
}

// Assembly:
subq $0x88, %rsp
leaq -0x17e(%rip), %rax      # 0x4b90
movq %rax, 0x40(%rsp)
leaq -0xfa(%rip), %rax       # 0x4c20
movq %rax, 0x48(%rsp)
movl $0x2, 0x50(%rsp)
movl $0xa, 0x54(%rsp)
movsd 0x7ff9(%rip), %xmm0     # 0xcd30
movsd %xmm0, 0x58(%rsp)
movsd 0x7fe3(%rip), %xmm0     # 0xcd28
movsd %xmm0, 0x60(%rsp)
leaq 0x70(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x7fe4(%rip), %rax      # 0xcd40
movq %rax, 0x30(%rsp)
movq 0x7fe0(%rip), %rax      # 0xcd48
movq %rax, 0x38(%rsp)
movq 0x7fdc(%rip), %rax      # 0xcd50
movq %rax, 0x20(%rsp)
movq 0x7fd8(%rip), %rax      # 0xcd58
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %r8
leaq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
callq 0x75f0
movq 0x7fb7(%rip), %rax      # 0xcd60
movq %rax, (%rsp)
movq 0x7fb4(%rip), %rax      # 0xcd68
movq %rax, 0x8(%rsp)
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
movl $0x2, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x21, %r8d
movl $0x1, %r9d
callq 0x8ec0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/gradient.c
// Function: morpheus_numeric_gradient
void morpheus_numeric_gradient(const morpheus_numeric_gradient_params_t *params,
                               const double *x,
                               void *data,
                               double *grad) {
  double *bumped_x = params->memory_buffer;
  int n = params->num_variables;
  morpheus_dcopy(n, x, bumped_x);
  for (int i = 0; i < n; i++) {
    double diff = x[i]*params->eps+params->eps;
    bumped_x[i] += diff;
    grad[i] = params->f(bumped_x, data);
    diff *= 2;
    bumped_x[i] -= diff;
    grad[i] -= params->f(bumped_x, data);
    grad[i] /= diff;
    bumped_x[i] = x[i];
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x6950
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x5280
movq 0x28(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x30(%rsp), %rax
movsd 0x10(%rax), %xmm2
movq 0x30(%rsp), %rax
movsd 0x10(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq *%rax
movq 0x18(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd 0x63d9(%rip), %xmm0     # 0xb5b8
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm1
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq *%rax
movaps %xmm0, %xmm1
movq 0x18(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd (%rsp), %xmm1
movq 0x18(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x515d
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/gradient_descent.c
// Function: morpheus_gradient_descent
void morpheus_gradient_descent(const morpheus_gradient_descent_params_t *params,
                               double *theta,
                               void *data) {

  double *grad = params->memory_buffer;

  int i;
  for (i = 0; i < params->max_iters; ++i) {
    params->df(theta, data, grad);
    morpheus_daxpy(params->num_variables, -params->alpha, grad, theta);

    double change = fabs(params->alpha)*morpheus_dnrm2(params->num_variables, grad);
    if (change < params->epsilon) {
      return;
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x5385
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
movq 0x30(%rsp), %rax
movl 0x28(%rax), %edi
movq 0x30(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x6a90
movq 0x30(%rsp), %rax
movsd 0x20(%rax), %xmm0
movaps 0x7a42(%rip), %xmm1     # 0xcd70
pand %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rax
movl 0x28(%rax), %edi
movq 0x18(%rsp), %rsi
callq 0x6ae0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
movq 0x30(%rsp), %rax
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5373
jmp 0x5385
jmp 0x5375
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x52b9
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/least_squares.c
// Function: morpheus_ls_hypothesis
void morpheus_ls_hypothesis(const morpheus_data_t *data,
                            const double *theta,
                            double *y) {
  const double alpha = 1;
  const double beta = 0;
  morpheus_dgemv(data->layout, morpheus_no_trans, data->num_examples,
                 data->num_features, alpha, data->x, theta, beta, y);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movsd 0x6215(%rip), %xmm0     # 0xb5c0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl 0x18(%rax), %edi
movq 0x30(%rsp), %rax
movl 0x14(%rax), %edx
movq 0x30(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x30(%rsp), %rax
movq (%rax), %r8
movq 0x28(%rsp), %r9
movq 0x20(%rsp), %rax
movl $0xb, %esi
movsd 0x61cf(%rip), %xmm0     # 0xb5c0
xorps %xmm1, %xmm1
movq %rax, (%rsp)
callq 0x69d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)