LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
leaq 0x571a(%rip), %rsi      # 0x75d0
leaq 0xe0(%rsp), %r12
movl $0xa0, %edx
movq %r12, %rdi
callq 0x1140
movaps 0x563e(%rip), %xmm0     # 0x7510
leaq 0x80(%rsp), %rbp
movaps %xmm0, (%rbp)
movaps 0x563b(%rip), %xmm0     # 0x7520
movaps %xmm0, 0x10(%rbp)
movabsq $0x401c000000000000, %rax # imm = 0x401C000000000000
movq %rax, 0x20(%rbp)
movaps 0x56b2(%rip), %xmm0     # 0x75b0
leaq 0x20(%rsp), %rbx
movaps %xmm0, (%rbx)
andl $0x0, 0x10(%rbx)
pushq $0x15
popq %rdi
pushq $0x4
popq %rsi
pushq $0x5
popq %r13
leaq 0xb0(%rsp), %r15
leaq 0x40(%rsp), %r14
movl %r13d, %edx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x4165
pushq $0x53
popq %r8
pushq $0x1
popq %r12
movq %rbp, %rdi
movq %r15, %rsi
movl %r13d, %edx
xorl %ecx, %ecx
movl %r12d, %r9d
callq 0x5b0f
movl %r12d, (%rsp)
pushq $0x54
popq %r8
pushq $0x14
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
xorl %ecx, %ecx
callq 0x55b6
movaps 0x5730(%rip), %xmm0     # 0x76a0
leaq 0x60(%rsp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps 0x5710(%rip), %xmm0     # 0x7690
movaps %xmm0, (%rbx)
movaps 0x55f6(%rip), %xmm0     # 0x7580
leaq 0x10(%rsp), %rbp
movaps %xmm0, (%rbp)
pushq $0x16
popq %rdi
movl %r13d, %esi
pushq $0x4
popq %r13
movl %r13d, %edx
leaq 0xe0(%rsp), %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x4165
pushq $0x59
popq %r8
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
xorl %ecx, %ecx
movl %r12d, %r9d
callq 0x5b0f
movl %r12d, (%rsp)
pushq $0x5a
popq %r8
movq %rbp, %rdi
movq %r14, %rsi
movl %r13d, %edx
xorl %ecx, %ecx
pushq $0x14
popq %r9
callq 0x55b6
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
leaq 0x55c0(%rip), %rsi      # 0x75d0
leaq 0xa0(%rsp), %rbx
movl $0xa0, %edx
movq %rbx, %rdi
callq 0x1140
movaps 0x5654(%rip), %xmm0     # 0x7680
leaq 0x20(%rsp), %r12
movaps %xmm0, 0x10(%r12)
movaps 0x5632(%rip), %xmm0     # 0x7670
movaps %xmm0, (%r12)
pushq $0x15
popq %rdi
pushq $0x4
popq %r15
pushq $0x5
popq %rbp
leaq 0x70(%rsp), %r14
movq %rsp, %r9
movl %r15d, %esi
movl %ebp, %edx
movq %rbx, %rcx
movq %r14, %r8
callq 0x4276
pushq $0x6b
popq %r8
pushq $0x1
popq %r13
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
movl %r13d, %r9d
callq 0x5b0f
movaps 0x54a9(%rip), %xmm0     # 0x7530
leaq 0x40(%rsp), %r12
movaps %xmm0, (%r12)
movaps 0x54a8(%rip), %xmm0     # 0x7540
movaps %xmm0, 0x10(%r12)
movabsq $0x4042800000000000, %rax # imm = 0x4042800000000000
movq %rax, 0x20(%r12)
pushq $0x16
popq %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %rbx, %rcx
movq %r14, %r8
movq %rsp, %r9
callq 0x4276
pushq $0x70
popq %r8
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
movl %r13d, %r9d
callq 0x5b0f
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
leaq 0x54cd(%rip), %rsi      # 0x75d0
leaq 0xa0(%rsp), %rbx
movl $0xa0, %edx
movq %rbx, %rdi
callq 0x1140
movaps 0x5581(%rip), %xmm0     # 0x76a0
leaq 0x20(%rsp), %r15
movaps %xmm0, 0x10(%r15)
movaps 0x5560(%rip), %xmm0     # 0x7690
movaps %xmm0, (%r15)
pushq $0x15
popq %rdi
pushq $0x4
popq %r12
pushq $0x5
popq %rbp
leaq 0x70(%rsp), %r14
movq %rsp, %r13
movl %r12d, %esi
movl %ebp, %edx
movq %rbx, %rcx
movq %r14, %r8
movq %r13, %r9
callq 0x4383
pushq $0x1
popq %r9
movl $0x81, %r8d
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x5b0f
movaps 0x5396(%rip), %xmm0     # 0x7510
leaq 0x40(%rsp), %r15
movaps %xmm0, (%r15)
movaps 0x5396(%rip), %xmm0     # 0x7520
movaps %xmm0, 0x10(%r15)
movabsq $0x401c000000000000, %rax # imm = 0x401C000000000000
movq %rax, 0x20(%r15)
pushq $0x16
popq %rdi
movl %ebp, %esi
movl %r12d, %edx
movq %rbx, %rcx
movq %r14, %r8
movq %r13, %r9
callq 0x4383
movl $0x86, %r8d
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
pushq $0x1
popq %r9
callq 0x5b0f
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
leaq 0x53da(%rip), %rsi      # 0x75d0
leaq 0x80(%rsp), %rbx
movl $0xa0, %edx
movq %rbx, %rdi
callq 0x1140
movaps 0x533e(%rip), %xmm0     # 0x7550
leaq 0x20(%rsp), %r13
movaps %xmm0, (%r13)
movaps 0x533d(%rip), %xmm0     # 0x7560
movaps %xmm0, 0x10(%r13)
movabsq $0x4052000000000000, %rax # imm = 0x4052000000000000
movq %rax, 0x20(%r13)
pushq $0x15
popq %rdi
pushq $0x4
popq %rbp
pushq $0x5
popq %r12
leaq 0x50(%rsp), %r14
movl %ebp, %esi
movl %r12d, %edx
movq %rbx, %rcx
movq %r14, %r8
callq 0x4494
pushq $0x1
popq %r15
movl $0x95, %r8d
movq %r13, %rdi
movq %r14, %rsi
movl %r12d, %edx
xorl %ecx, %ecx
movl %r15d, %r9d
callq 0x5b0f
movaps 0x5447(%rip), %xmm0     # 0x76c0
movq %rsp, %r13
movaps %xmm0, 0x10(%r13)
movaps 0x5428(%rip), %xmm0     # 0x76b0
movaps %xmm0, (%r13)
pushq $0x16
popq %rdi
movl %r12d, %esi
movl %ebp, %edx
movq %rbx, %rcx
movq %r14, %r8
callq 0x4494
movl $0x99, %r8d
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
movl %r15d, %r9d
callq 0x5b0f
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
leaq 0x52ee(%rip), %rsi      # 0x75d0
leaq 0x80(%rsp), %rbx
movl $0xa0, %edx
movq %rbx, %rdi
callq 0x1140
movaps 0x53c2(%rip), %xmm0     # 0x76c0
movq %rsp, %r13
movaps %xmm0, 0x10(%r13)
movaps 0x53a3(%rip), %xmm0     # 0x76b0
movaps %xmm0, (%r13)
pushq $0x15
popq %rdi
pushq $0x4
popq %r12
pushq $0x5
popq %rbp
leaq 0x50(%rsp), %r14
movl %r12d, %esi
movl %ebp, %edx
movq %rbx, %rcx
movq %r14, %r8
callq 0x456c
pushq $0x1
popq %r15
movl $0xa8, %r8d
movq %r13, %rdi
movq %r14, %rsi
movl %r12d, %edx
xorl %ecx, %ecx
movl %r15d, %r9d
callq 0x5b0f
movaps 0x51fb(%rip), %xmm0     # 0x7550
leaq 0x20(%rsp), %r13
movaps %xmm0, (%r13)
movaps 0x51fa(%rip), %xmm0     # 0x7560
movaps %xmm0, 0x10(%r13)
movabsq $0x4052000000000000, %rax # imm = 0x4052000000000000
movq %rax, 0x20(%r13)
pushq $0x16
popq %rdi
movl %ebp, %esi
movl %r12d, %edx
movq %rbx, %rcx
movq %r14, %r8
callq 0x456c
movl $0xac, %r8d
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
movl %r15d, %r9d
callq 0x5b0f
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/tests/numeric_gradient_test.c
// Function: test_numeric_gradient
void test_numeric_gradient() {
  morpheus_reg_t reg_none;
  reg_none.type = morpheus_reg_none;

  morpheus_reg_t reg_l2;
  reg_l2.type = morpheus_reg_l2;
  reg_l2.lambda = 1;

  double X[] = {
    1, 3,
    1, 5,
    1, 10,
    1, 0,
    1, 4
  };
  double y[] = {9, 13, 23, 3, 11};

  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;

  double tmp_buffer2[2*5];
  morpheus_numeric_gradient_params_t params;
  params.f = (morpheus_f)morpheus_ls_cost;
  params.num_variables = data.data.num_features;
  params.eps = 1e-5;
  params.memory_buffer = tmp_buffer2;

  double theta[] = {3, 3};

  double grad[2];
  double num_grad[2];

  // No regularization
  data.reg = reg_none;
  morpheus_ls_gradient(theta, &data, grad);

  morpheus_numeric_gradient(&params, theta, &data, num_grad);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(num_grad, grad, 2);

  // L2 regularization
  data.reg = reg_l2;
  morpheus_ls_gradient(theta, &data, grad);

  morpheus_numeric_gradient(&params, theta, &data, num_grad);
  TEST_ASSERT_EQUAL_DOUBLE_ARRAY(num_grad, grad, 2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
leaq 0x5310(%rip), %rsi      # 0x76e0
pushq $0xa
popq %rcx
leaq 0x150(%rsp), %rax
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movaps 0x4d08(%rip), %xmm0     # 0x70f0
leaq 0x50(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps 0x4d09(%rip), %xmm0     # 0x7100
movaps %xmm0, 0x10(%rcx)
movabsq $0x4026000000000000, %rdx # imm = 0x4026000000000000
movq %rdx, 0x20(%rcx)
leaq 0x78(%rsp), %rbx
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movabsq $0x500000002, %rax      # imm = 0x500000002
movq %rax, 0x10(%rbx)
movl $0x15, 0x18(%rbx)
leaq 0x100(%rsp), %rax
movq %rax, 0x30(%rbx)
leaq 0x1986(%rip), %rax      # 0x3dc3
leaq 0x30(%rsp), %r14
movq %rax, (%r14)
movl $0x2, 0x8(%r14)
movabsq $0x3ee4f8b588e368f1, %rax # imm = 0x3EE4F8B588E368F1
movq %rax, 0x10(%r14)
leaq 0xb0(%rsp), %rax
movq %rax, 0x18(%r14)
movaps 0x5262(%rip), %xmm0     # 0x76d0
leaq 0x20(%rsp), %r12
movaps %xmm0, (%r12)
andl $0x0, 0x20(%rbx)
leaq 0x10(%rsp), %r15
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3dd3
movq %rsp, %r13
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x3aa8
pushq $0x2
popq %rbp
pushq $0x32
popq %r8
pushq $0x1
popq %r9
movq %r13, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x5b0f
movl $0x1, 0x20(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x28(%rbx)
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3dd3
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x3aa8
pushq $0x39
popq %r8
movq %r13, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
pushq $0x1
popq %r9
callq 0x5b0f
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsp, %r15
xorps %xmm0, %xmm0
leaq 0xb0(%rsp), %rbx
movaps %xmm0, (%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x30(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rbx)
movaps 0x51db(%rip), %xmm0     # 0x7730
movaps %xmm0, 0x10(%rbx)
movabsq $0x4014000000000000, %rax # imm = 0x4014000000000000
movq %rax, 0x20(%rbx)
movaps 0x51d2(%rip), %xmm0     # 0x7740
movups %xmm0, 0x38(%rbx)
leaq 0x5367(%rip), %rsi      # 0x78e0
pushq $0x9
popq %rcx
leaq 0x60(%rsp), %r14
movq %r14, %rdi
rep  movsq (%rsi), %es:(%rdi)
pushq $0x3
popq %rdi
movq %rsp, %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rsi
callq 0x4794
movslq %eax, %rsi
pushq $0x14
popq %rcx
pushq $0x14
popq %r8
xorl %edi, %edi
xorl %edx, %edx
callq 0x5533
pushq $0x9
popq %rdx
pushq $0x15
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5b0f
movq %r15, %rsp
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movaps 0x539a(%rip), %xmm0     # 0x7980
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
movabsq $0x4008000000000000, %rcx # imm = 0x4008000000000000
movq %rcx, 0x10(%rax)
movaps 0x539d(%rip), %xmm0     # 0x79a0
movq %rsp, %r8
movaps %xmm0, (%r8)
movabsq $0x4018000000000000, %rcx # imm = 0x4018000000000000
movq %rcx, 0x10(%r8)
leaq 0x53a1(%rip), %rsi      # 0x79c0
pushq $0x9
popq %rdx
leaq 0x90(%rsp), %rbx
movq %rdx, %rcx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x52f6(%rip), %rsi      # 0x7930
leaq 0x40(%rsp), %r14
movq %rdx, %rcx
movq %r14, %rdi
rep  movsq (%rsi), %es:(%rdi)
pushq $0x15
popq %rdi
pushq $0x3
popq %rdx
movsd 0x522a(%rip), %xmm0     # 0x7880
movl %edx, %esi
movq %rax, %rcx
movq %rbx, %r9
callq 0x4810
pushq $0x9
popq %rdx
pushq $0x26
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5b0f
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movaps 0x52e9(%rip), %xmm0     # 0x7980
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
movabsq $0x4008000000000000, %rcx # imm = 0x4008000000000000
movq %rcx, 0x10(%rax)
movaps 0x52ec(%rip), %xmm0     # 0x79a0
movq %rsp, %r8
movaps %xmm0, (%r8)
movabsq $0x4018000000000000, %rcx # imm = 0x4018000000000000
movq %rcx, 0x10(%r8)
leaq 0x52f0(%rip), %rsi      # 0x79c0
pushq $0x9
popq %rdx
leaq 0x90(%rsp), %rbx
movq %rdx, %rcx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x5325(%rip), %rsi      # 0x7a10
leaq 0x40(%rsp), %r14
movq %rdx, %rcx
movq %r14, %rdi
rep  movsq (%rsi), %es:(%rdi)
pushq $0x16
popq %rdi
pushq $0x3
popq %rdx
movsd 0x5179(%rip), %xmm0     # 0x7880
movl %edx, %esi
movq %rax, %rcx
movq %rbx, %r9
callq 0x4810
pushq $0x9
popq %rdx
pushq $0x36
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5b0f
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movaps 0x5ac8(%rip), %xmm0     # 0x8210
leaq 0x20(%rsp), %rax
movaps %xmm0, 0x10(%rax)
movaps 0x5aa8(%rip), %xmm0     # 0x8200
movaps %xmm0, (%rax)
movaps 0x535e(%rip), %xmm0     # 0x7ac0
movq %rsp, %r8
movaps %xmm0, (%r8)
movabsq $0x401c000000000000, %rcx # imm = 0x401C000000000000
movq %rcx, 0x10(%r8)
leaq 0x5362(%rip), %rsi      # 0x7ae0
pushq $0xc
popq %rdx
leaq 0xa0(%rsp), %rbx
movq %rdx, %rcx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x52c7(%rip), %rsi      # 0x7a60
leaq 0x40(%rsp), %r14
movq %rdx, %rcx
movq %r14, %rdi
rep  movsq (%rsi), %es:(%rdi)
pushq $0x15
popq %rdi
pushq $0x4
popq %rsi
pushq $0x3
popq %rdx
movsd 0x50d0(%rip), %xmm0     # 0x7888
movq %rax, %rcx
movq %rbx, %r9
callq 0x4810
pushq $0xc
popq %rdx
pushq $0x49
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5b0f
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movaps 0x5a19(%rip), %xmm0     # 0x8210
leaq 0x20(%rsp), %rax
movaps %xmm0, 0x10(%rax)
movaps 0x59f9(%rip), %xmm0     # 0x8200
movaps %xmm0, (%rax)
movaps 0x52af(%rip), %xmm0     # 0x7ac0
movq %rsp, %r8
movaps %xmm0, (%r8)
movabsq $0x401c000000000000, %rcx # imm = 0x401C000000000000
movq %rcx, 0x10(%r8)
leaq 0x52b3(%rip), %rsi      # 0x7ae0
pushq $0xc
popq %rdx
leaq 0xa0(%rsp), %rbx
movq %rdx, %rcx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x52f8(%rip), %rsi      # 0x7b40
leaq 0x40(%rsp), %r14
movq %rdx, %rcx
movq %r14, %rdi
rep  movsq (%rsi), %es:(%rdi)
pushq $0x16
popq %rdi
pushq $0x4
popq %rsi
pushq $0x3
popq %rdx
movsd 0x5021(%rip), %xmm0     # 0x7888
movq %rax, %rcx
movq %rbx, %r9
callq 0x4810
pushq $0xc
popq %rdx
pushq $0x5a
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5b0f
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movaps 0x4eaa(%rip), %xmm0     # 0x7750
movq %rsp, %r10
movaps %xmm0, (%r10)
movaps 0x4eac(%rip), %xmm0     # 0x7760
movaps %xmm0, 0x10(%r10)
movaps 0x4eb0(%rip), %xmm0     # 0x7770
movaps %xmm0, 0x20(%r10)
leaq 0x52d4(%rip), %rsi      # 0x7ba0
pushq $0xc
popq %rcx
leaq 0xb0(%rsp), %rax
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movaps 0x538c(%rip), %xmm0     # 0x7c70
leaq 0x70(%rsp), %rbx
movaps %xmm0, 0x30(%rbx)
movaps 0x536c(%rip), %xmm0     # 0x7c60
movaps %xmm0, 0x20(%rbx)
movaps 0x5351(%rip), %xmm0     # 0x7c50
movaps %xmm0, 0x10(%rbx)
movaps 0x5336(%rip), %xmm0     # 0x7c40
movaps %xmm0, (%rbx)
movaps 0x539c(%rip), %xmm0     # 0x7cb0
leaq 0x30(%rsp), %r14
movaps %xmm0, 0x30(%r14)
movaps 0x537b(%rip), %xmm0     # 0x7ca0
movaps %xmm0, 0x20(%r14)
movaps 0x535f(%rip), %xmm0     # 0x7c90
movaps %xmm0, 0x10(%r14)
movaps 0x5343(%rip), %xmm0     # 0x7c80
movaps %xmm0, (%r14)
subq $0x8, %rsp
pushq $0x15
popq %rdi
pushq $0xb
popq %rdx
pushq $0x2
popq %rcx
pushq $0x4
popq %r8
pushq $0x3
popq %r9
movsd 0x4f32(%rip), %xmm0     # 0x7890
movsd 0x4f1a(%rip), %xmm1     # 0x7880
movl %edx, %esi
pushq %rbx
pushq %rax
pushq %r10
callq 0x484e
addq $0x20, %rsp
pushq $0x8
popq %rdx
pushq $0x6f
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5b0f
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movaps 0x4dd7(%rip), %xmm0     # 0x7780
movq %rsp, %r10
movaps %xmm0, (%r10)
movaps 0x4dd9(%rip), %xmm0     # 0x7790
movaps %xmm0, 0x10(%r10)
movaps 0x4ddd(%rip), %xmm0     # 0x77a0
movaps %xmm0, 0x20(%r10)
leaq 0x52f1(%rip), %rsi      # 0x7cc0
pushq $0xc
popq %rcx
leaq 0xb0(%rsp), %rax
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movaps 0x5249(%rip), %xmm0     # 0x7c30
leaq 0x70(%rsp), %rbx
movaps %xmm0, 0x30(%rbx)
movaps 0x5229(%rip), %xmm0     # 0x7c20
movaps %xmm0, 0x20(%rbx)
movaps 0x520e(%rip), %xmm0     # 0x7c10
movaps %xmm0, 0x10(%rbx)
movaps 0x51f3(%rip), %xmm0     # 0x7c00
movaps %xmm0, (%rbx)
movaps 0x5379(%rip), %xmm0     # 0x7d90
leaq 0x30(%rsp), %r14
movaps %xmm0, 0x30(%r14)
movaps 0x5358(%rip), %xmm0     # 0x7d80
movaps %xmm0, 0x20(%r14)
movaps 0x533c(%rip), %xmm0     # 0x7d70
movaps %xmm0, 0x10(%r14)
movaps 0x5320(%rip), %xmm0     # 0x7d60
movaps %xmm0, (%r14)
subq $0x8, %rsp
pushq $0x16
popq %rdi
pushq $0xb
popq %rdx
pushq $0x2
popq %rcx
pushq $0x4
popq %r8
pushq $0x3
popq %r9
movsd 0x4e37(%rip), %xmm0     # 0x7898
movsd 0x4e17(%rip), %xmm1     # 0x7880
movl %edx, %esi
pushq %rbx
pushq %rax
pushq %r10
callq 0x484e
addq $0x20, %rsp
pushq $0x8
popq %rdx
pushq $0x1
popq %r9
movl $0x8a, %r8d
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5b0f
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movaps 0x4d02(%rip), %xmm0     # 0x77b0
movq %rsp, %r10
movaps %xmm0, (%r10)
movaps 0x4d04(%rip), %xmm0     # 0x77c0
movaps %xmm0, 0x10(%r10)
movaps 0x4d08(%rip), %xmm0     # 0x77d0
movaps %xmm0, 0x20(%r10)
leaq 0x51ec(%rip), %rsi      # 0x7cc0
pushq $0xc
popq %rcx
leaq 0xb0(%rsp), %rax
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movaps 0x5184(%rip), %xmm0     # 0x7c70
leaq 0x70(%rsp), %rbx
movaps %xmm0, 0x30(%rbx)
movaps 0x5164(%rip), %xmm0     # 0x7c60
movaps %xmm0, 0x20(%rbx)
movaps 0x5149(%rip), %xmm0     # 0x7c50
movaps %xmm0, 0x10(%rbx)
movaps 0x512e(%rip), %xmm0     # 0x7c40
movaps %xmm0, (%rbx)
movaps 0x5194(%rip), %xmm0     # 0x7cb0
leaq 0x30(%rsp), %r14
movaps %xmm0, 0x30(%r14)
movaps 0x5173(%rip), %xmm0     # 0x7ca0
movaps %xmm0, 0x20(%r14)
movaps 0x5157(%rip), %xmm0     # 0x7c90
movaps %xmm0, 0x10(%r14)
movaps 0x513b(%rip), %xmm0     # 0x7c80
movaps %xmm0, (%r14)
subq $0x8, %rsp
pushq $0x15
popq %rdi
pushq $0xc
popq %rdx
pushq $0x2
popq %rcx
pushq $0x4
popq %r8
pushq $0x3
popq %r9
movsd 0x4d2a(%rip), %xmm0     # 0x7890
movsd 0x4d12(%rip), %xmm1     # 0x7880
movl %edx, %esi
pushq %rbx
pushq %rax
pushq %r10
callq 0x484e
addq $0x20, %rsp
pushq $0x8
popq %rdx
pushq $0x1
popq %r9
movl $0xa1, %r8d
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5b0f
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movaps 0x4b9d(%rip), %xmm0     # 0x7750
movq %rsp, %r10
movaps %xmm0, (%r10)
movaps 0x4b9f(%rip), %xmm0     # 0x7760
movaps %xmm0, 0x10(%r10)
movaps 0x4ba3(%rip), %xmm0     # 0x7770
movaps %xmm0, 0x20(%r10)
leaq 0x50e7(%rip), %rsi      # 0x7cc0
pushq $0xc
popq %rcx
leaq 0xb0(%rsp), %rax
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movaps 0x515f(%rip), %xmm0     # 0x7d50
leaq 0x70(%rsp), %rbx
movaps %xmm0, 0x30(%rbx)
movaps 0x513f(%rip), %xmm0     # 0x7d40
movaps %xmm0, 0x20(%rbx)
movaps 0x5124(%rip), %xmm0     # 0x7d30
movaps %xmm0, 0x10(%rbx)
movaps 0x5109(%rip), %xmm0     # 0x7d20
movaps %xmm0, (%rbx)
movaps 0x516f(%rip), %xmm0     # 0x7d90
leaq 0x30(%rsp), %r14
movaps %xmm0, 0x30(%r14)
movaps 0x514e(%rip), %xmm0     # 0x7d80
movaps %xmm0, 0x20(%r14)
movaps 0x5132(%rip), %xmm0     # 0x7d70
movaps %xmm0, 0x10(%r14)
movaps 0x5116(%rip), %xmm0     # 0x7d60
movaps %xmm0, (%r14)
subq $0x8, %rsp
pushq $0x16
popq %rdi
pushq $0xc
popq %rsi
pushq $0xb
popq %rdx
pushq $0x2
popq %rcx
pushq $0x4
popq %r8
pushq $0x3
popq %r9
movsd 0x4c22(%rip), %xmm0     # 0x7890
movsd 0x4c2a(%rip), %xmm1     # 0x78a0
pushq %rbx
pushq %rax
pushq %r10
callq 0x484e
addq $0x20, %rsp
pushq $0x8
popq %rdx
pushq $0x1
popq %r9
movl $0xbb, %r8d
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5b0f
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movaps 0x4a96(%rip), %xmm0     # 0x7750
leaq 0x50(%rsp), %r8
movaps %xmm0, (%r8)
movaps 0x4a96(%rip), %xmm0     # 0x7760
movaps %xmm0, 0x10(%r8)
movaps 0x4a9a(%rip), %xmm0     # 0x7770
movaps %xmm0, 0x20(%r8)
movaps 0x50be(%rip), %xmm0     # 0x7da0
leaq 0x30(%rsp), %r9
movaps %xmm0, (%r9)
movabsq $-0x3fce000000000000, %rax # imm = 0xC032000000000000
movq %rax, 0x10(%r9)
movaps 0x4b60(%rip), %xmm0     # 0x7860
leaq 0x20(%rsp), %rbx
movaps %xmm0, (%rbx)
movaps 0x4b61(%rip), %xmm0     # 0x7870
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq %rbx, (%rsp)
pushq $0x15
popq %rdi
pushq $0xb
popq %rsi
pushq $0x2
popq %rbp
pushq $0x3
popq %rcx
movsd 0x4b68(%rip), %xmm0     # 0x7898
movsd 0x4b70(%rip), %xmm1     # 0x78a8
movl %ebp, %edx
callq 0x4720
pushq $0x1
popq %r9
movl $0xcb, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x5b0f
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movaps 0x4a3a(%rip), %xmm0     # 0x77b0
leaq 0x50(%rsp), %r8
movaps %xmm0, (%r8)
movaps 0x4a3a(%rip), %xmm0     # 0x77c0
movaps %xmm0, 0x10(%r8)
movaps 0x4a3e(%rip), %xmm0     # 0x77d0
movaps %xmm0, 0x20(%r8)
movaps 0x5002(%rip), %xmm0     # 0x7da0
leaq 0x30(%rsp), %r9
movaps %xmm0, (%r9)
movabsq $-0x3fce000000000000, %rax # imm = 0xC032000000000000
movq %rax, 0x10(%r9)
movaps 0x4aa4(%rip), %xmm0     # 0x7860
leaq 0x20(%rsp), %rbx
movaps %xmm0, (%rbx)
movaps 0x4aa5(%rip), %xmm0     # 0x7870
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq %rbx, (%rsp)
pushq $0x16
popq %rdi
pushq $0xb
popq %rsi
pushq $0x2
popq %rbp
pushq $0x3
popq %rcx
movsd 0x4aac(%rip), %xmm0     # 0x7898
movsd 0x4ab4(%rip), %xmm1     # 0x78a8
movl %ebp, %edx
callq 0x4720
pushq $0x1
popq %r9
movl $0xdc, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x5b0f
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movaps 0x497e(%rip), %xmm0     # 0x77b0
leaq 0x50(%rsp), %r8
movaps %xmm0, (%r8)
movaps 0x497e(%rip), %xmm0     # 0x77c0
movaps %xmm0, 0x10(%r8)
movaps 0x4982(%rip), %xmm0     # 0x77d0
movaps %xmm0, 0x20(%r8)
movaps 0x4f46(%rip), %xmm0     # 0x7da0
leaq 0x30(%rsp), %r9
movaps %xmm0, (%r9)
movabsq $-0x3fce000000000000, %rax # imm = 0xC032000000000000
movq %rax, 0x10(%r9)
movaps 0x49e8(%rip), %xmm0     # 0x7860
leaq 0x20(%rsp), %rbx
movaps %xmm0, (%rbx)
movaps 0x49e9(%rip), %xmm0     # 0x7870
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq %rbx, (%rsp)
pushq $0x15
popq %rdi
pushq $0xc
popq %rsi
pushq $0x3
popq %rdx
pushq $0x2
popq %rbp
movsd 0x49f0(%rip), %xmm0     # 0x7898
movsd 0x49f8(%rip), %xmm1     # 0x78a8
movl %ebp, %ecx
callq 0x4720
pushq $0x1
popq %r9
movl $0xed, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x5b0f
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movaps 0x4862(%rip), %xmm0     # 0x7750
leaq 0x50(%rsp), %r8
movaps %xmm0, (%r8)
movaps 0x4862(%rip), %xmm0     # 0x7760
movaps %xmm0, 0x10(%r8)
movaps 0x4866(%rip), %xmm0     # 0x7770
movaps %xmm0, 0x20(%r8)
movaps 0x4e8a(%rip), %xmm0     # 0x7da0
leaq 0x30(%rsp), %r9
movaps %xmm0, (%r9)
movabsq $-0x3fce000000000000, %rax # imm = 0xC032000000000000
movq %rax, 0x10(%r9)
movaps 0x492c(%rip), %xmm0     # 0x7860
leaq 0x20(%rsp), %rbx
movaps %xmm0, (%rbx)
movaps 0x492d(%rip), %xmm0     # 0x7870
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq %rbx, (%rsp)
pushq $0x16
popq %rdi
pushq $0xc
popq %rsi
pushq $0x3
popq %rdx
pushq $0x2
popq %rbp
movsd 0x4934(%rip), %xmm0     # 0x7898
movsd 0x493c(%rip), %xmm1     # 0x78a8
movl %ebp, %ecx
callq 0x4720
pushq $0x1
popq %r9
movl $0xfd, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x5b0f
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movaps 0x4839(%rip), %xmm0     # 0x77e0
leaq 0x30(%rsp), %rbx
movaps %xmm0, (%rbx)
movaps 0x483a(%rip), %xmm0     # 0x77f0
movaps %xmm0, 0x10(%rbx)
movaps 0x483f(%rip), %xmm0     # 0x7800
movaps %xmm0, 0x20(%rbx)
pushq $0x6
popq %rbp
movq %rsp, %r14
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x46fa
pushq $0x1
popq %r9
movl $0x105, %r8d            # imm = 0x105
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x5b0f
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x58, %rsp
movaps 0x47bf(%rip), %xmm0     # 0x7810
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps 0x47c0(%rip), %xmm0     # 0x7820
movaps %xmm0, 0x10(%rsi)
movabsq $0x4031000000000000, %rax # imm = 0x4031000000000000
movq %rax, 0x20(%rsi)
movaps 0x47b7(%rip), %xmm0     # 0x7830
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps 0x47ba(%rip), %xmm0     # 0x7840
movaps %xmm0, 0x10(%rdx)
movabsq $0x4040800000000000, %rax # imm = 0x4040800000000000
movq %rax, 0x20(%rdx)
pushq $0x5
popq %rdi
callq 0x4786
movaps %xmm0, %xmm2
movsd 0x480d(%rip), %xmm0     # 0x78b8
movsd 0x480d(%rip), %xmm1     # 0x78c0
movl $0x117, %esi            # imm = 0x117
xorl %edi, %edi
callq 0x5cd4
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movaps 0x4637(%rip), %xmm0     # 0x7750
leaq 0x30(%rsp), %rbx
movaps %xmm0, (%rbx)
movaps 0x4638(%rip), %xmm0     # 0x7760
movaps %xmm0, 0x10(%rbx)
movabsq $0x4014000000000000, %rax # imm = 0x4014000000000000
movq %rax, 0x20(%rbx)
movaps 0x468f(%rip), %xmm0     # 0x77d0
movq %rsp, %r14
movaps %xmm0, (%r14)
movaps 0x4701(%rip), %xmm0     # 0x7850
movaps %xmm0, 0x10(%r14)
movabsq $0x402e000000000000, %rax # imm = 0x402E000000000000
movq %rax, 0x20(%r14)
pushq $0x5
popq %rbp
movsd 0x476b(%rip), %xmm0     # 0x78d8
movl %ebp, %edi
movq %rbx, %rsi
callq 0x46f2
pushq $0x1
popq %r9
movl $0x129, %r8d            # imm = 0x129
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x5b0f
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movaps 0x4c95(%rip), %xmm0     # 0x7e40
leaq 0x80(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movaps 0x4c72(%rip), %xmm0     # 0x7e30
movaps %xmm0, 0x10(%rsi)
movaps 0x4c57(%rip), %xmm0     # 0x7e20
movaps %xmm0, (%rsi)
movabsq $0x401c000000000000, %rax # imm = 0x401C000000000000
movq %rax, 0x30(%rsi)
movaps 0x4c9f(%rip), %xmm0     # 0x7e80
leaq 0x40(%rsp), %rbx
movaps %xmm0, 0x20(%rbx)
movaps 0x4c7f(%rip), %xmm0     # 0x7e70
movaps %xmm0, 0x10(%rbx)
movaps 0x4c64(%rip), %xmm0     # 0x7e60
movaps %xmm0, (%rbx)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x30(%rbx)
movabsq $-0x3fe0000000000000, %rax # imm = 0xC020000000000000
movq %rsp, %r14
movq %rax, 0x30(%r14)
movaps 0x4c9b(%rip), %xmm0     # 0x7ec0
movaps %xmm0, 0x20(%r14)
movaps 0x4c7f(%rip), %xmm0     # 0x7eb0
movaps %xmm0, 0x10(%r14)
movaps 0x4c63(%rip), %xmm0     # 0x7ea0
movaps %xmm0, (%r14)
pushq $0x7
popq %rbp
movsd 0x4634(%rip), %xmm0     # 0x7880
movl %ebp, %edi
movq %rbx, %rdx
callq 0x4770
pushq $0x1
popq %r9
movl $0x134, %r8d            # imm = 0x134
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x5b0f
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x640, %rsp            # imm = 0x640
leaq 0x4c56(%rip), %rsi      # 0x7ee0
movq %rsp, %rdi
movl $0x320, %edx            # imm = 0x320
callq 0x1140
pushq $0x31
popq %rax
cmpq $0x64, %rax
je 0x32ba
leal 0x64(%rax), %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, (%rsp,%rax,8)
movsd %xmm0, 0x320(%rsp,%rax,8)
incq %rax
jmp 0x329a
pushq $0x7
popq %rdi
leaq 0x320(%rsp), %rbx
movq %rbx, %rsi
callq 0x48d2
movq %rsp, %rdi
pushq $0x64
popq %rdx
pushq $0x1
popq %r9
movl $0x146, %r8d            # imm = 0x146
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5b0f
addq $0x640, %rsp            # imm = 0x640
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x48, %rsp
movaps 0x4f75(%rip), %xmm0     # 0x8270
movq %rsp, %rsi
movaps %xmm0, 0x30(%rsi)
movaps 0x4f57(%rip), %xmm0     # 0x8260
movaps %xmm0, 0x20(%rsi)
movaps 0x4f3c(%rip), %xmm0     # 0x8250
movaps %xmm0, 0x10(%rsi)
movaps 0x4f21(%rip), %xmm0     # 0x8240
movaps %xmm0, (%rsi)
pushq $0x8
popq %rdi
callq 0x492c
movaps %xmm0, %xmm2
movsd 0x4eeb(%rip), %xmm0     # 0x8220
movsd 0x4eeb(%rip), %xmm1     # 0x8228
pushq $0x9
popq %rsi
xorl %edi, %edi
callq 0x5cd4
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x48, %rsp
movaps 0x4f19(%rip), %xmm0     # 0x8270
movq %rsp, %rsi
movaps %xmm0, 0x30(%rsi)
movaps 0x4efb(%rip), %xmm0     # 0x8260
movaps %xmm0, 0x20(%rsi)
movaps 0x4ee0(%rip), %xmm0     # 0x8250
movaps %xmm0, 0x10(%rsi)
movaps 0x4ec5(%rip), %xmm0     # 0x8240
movaps %xmm0, (%rsi)
movsd 0x4ea2(%rip), %xmm0     # 0x8228
pushq $0x8
popq %rdi
callq 0x4954
movaps %xmm0, %xmm2
movsd 0x4e97(%rip), %xmm0     # 0x8230
movsd 0x4e97(%rip), %xmm1     # 0x8238
pushq $0x12
popq %rsi
xorl %edi, %edi
callq 0x5cd4
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x48, %rsp
movaps 0x4eb5(%rip), %xmm0     # 0x8270
movq %rsp, %rsi
movaps %xmm0, 0x30(%rsi)
movaps 0x4e97(%rip), %xmm0     # 0x8260
movaps %xmm0, 0x20(%rsi)
movaps 0x4e7c(%rip), %xmm0     # 0x8250
movaps %xmm0, 0x10(%rsi)
movaps 0x4e61(%rip), %xmm0     # 0x8240
movaps %xmm0, (%rsi)
pushq $0x8
popq %rdi
callq 0x499d
movaps %xmm0, %xmm2
movsd 0x4e3b(%rip), %xmm0     # 0x8230
movsd 0x4e3b(%rip), %xmm1     # 0x8238
pushq $0x1a
popq %rsi
xorl %edi, %edi
callq 0x5cd4
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x4e5c(%rip), %rsi      # 0x8280
pushq $0xc
popq %rcx
leaq 0x60(%rsp), %r8
movq %r8, %rdi
rep  movsq (%rsi), %es:(%rdi)
movaps 0x4ef7(%rip), %xmm0     # 0x8330
leaq 0x40(%rsp), %r12
movaps %xmm0, 0x10(%r12)
movaps 0x4ed5(%rip), %xmm0     # 0x8320
movaps %xmm0, (%r12)
movaps 0x4e89(%rip), %xmm0     # 0x82e0
movq %rsp, %r14
movaps %xmm0, (%r14)
movabsq $0x4049400000000000, %rax # imm = 0x4049400000000000
movq %rax, 0x10(%r14)
pushq $0x15
popq %rdi
pushq $0x3
popq %rbp
pushq $0x4
popq %r13
leaq 0x20(%rsp), %r15
movl %ebp, %esi
movl %r13d, %edx
movq %r8, %rcx
movq %r15, %r8
callq 0x49c3
pushq $0x2d
popq %r8
pushq $0x1
popq %rbx
movq %r12, %rdi
movq %r15, %rsi
movl %r13d, %edx
xorl %ecx, %ecx
movl %ebx, %r9d
callq 0x5b0f
pushq $0x16
popq %rdi
movl %r13d, %esi
movl %ebp, %edx
leaq 0x60(%rsp), %rcx
movq %r15, %r8
callq 0x49c3
pushq $0x30
popq %r8
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
movl %ebx, %r9d
callq 0x5b0f
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x4d86(%rip), %rsi      # 0x8280
pushq $0xc
popq %rcx
leaq 0x60(%rsp), %r8
movq %r8, %rdi
rep  movsq (%rsi), %es:(%rdi)
movaps 0x4dd1(%rip), %xmm0     # 0x82e0
movq %rsp, %r12
movaps %xmm0, (%r12)
movabsq $0x4049400000000000, %rax # imm = 0x4049400000000000
movq %rax, 0x10(%r12)
movaps 0x4e03(%rip), %xmm0     # 0x8330
leaq 0x40(%rsp), %r14
movaps %xmm0, 0x10(%r14)
movaps 0x4de2(%rip), %xmm0     # 0x8320
movaps %xmm0, (%r14)
pushq $0x15
popq %rdi
pushq $0x3
popq %r13
pushq $0x4
popq %rbp
leaq 0x20(%rsp), %r15
movl %r13d, %esi
movl %ebp, %edx
movq %r8, %rcx
movq %r15, %r8
callq 0x49fe
pushq $0x40
popq %r8
pushq $0x1
popq %rbx
movq %r12, %rdi
movq %r15, %rsi
movl %r13d, %edx
xorl %ecx, %ecx
movl %ebx, %r9d
callq 0x5b0f
pushq $0x16
popq %rdi
movl %ebp, %esi
movl %r13d, %edx
leaq 0x60(%rsp), %rcx
movq %r15, %r8
callq 0x49fe
pushq $0x43
popq %r8
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
movl %ebx, %r9d
callq 0x5b0f
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq