LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0x4cb0(%rip), %rsi      # 0x8280
pushq $0xc
popq %rcx
leaq 0xa0(%rsp), %rdi
movq %rdi, %r8
rep  movsq (%rsi), %es:(%rdi)
movaps 0x4d48(%rip), %xmm0     # 0x8330
leaq 0x80(%rsp), %rcx
movaps %xmm0, 0x10(%rcx)
movaps 0x4d25(%rip), %xmm0     # 0x8320
movaps %xmm0, (%rcx)
movaps 0x4d4b(%rip), %xmm0     # 0x8350
leaq 0x60(%rsp), %r13
movaps %xmm0, 0x10(%r13)
movaps 0x4d2a(%rip), %xmm0     # 0x8340
movaps %xmm0, (%r13)
movaps 0x4cbe(%rip), %xmm0     # 0x82e0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movabsq $0x4049400000000000, %rax # imm = 0x4049400000000000
movq %rax, 0x10(%r15)
movaps 0x4cc0(%rip), %xmm0     # 0x8300
movq %rsp, %r14
movaps %xmm0, (%r14)
movabsq $0x404396ec17ebaf10, %rax # imm = 0x404396EC17EBAF10
movq %rax, 0x10(%r14)
pushq $0x15
popq %rdi
pushq $0x3
popq %rbp
pushq $0x4
popq %rbx
leaq 0x40(%rsp), %r12
movl %ebp, %esi
movl %ebx, %edx
movq %r12, %r9
callq 0x4a39
pushq $0x56
popq %r8
pushq $0x1
popq %r9
movq %r13, %rdi
movq %r12, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
movl %r9d, %r13d
callq 0x5b0f
pushq $0x16
popq %rdi
movl %ebx, %esi
movl %ebp, %edx
movq %r15, %rcx
leaq 0xa0(%rsp), %r8
movq %r12, %r9
callq 0x4a39
pushq $0x59
popq %r8
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
movl %r13d, %r9d
callq 0x5b0f
addq $0x108, %rsp            # imm = 0x108
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_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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0x4b9d(%rip), %rsi      # 0x8280
pushq $0xc
popq %rcx
leaq 0xa0(%rsp), %rdi
movq %rdi, %r8
rep  movsq (%rsi), %es:(%rdi)
movaps 0x4be5(%rip), %xmm0     # 0x82e0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movabsq $0x4049400000000000, %rax # imm = 0x4049400000000000
movq %rax, 0x10(%rcx)
movaps 0x4be8(%rip), %xmm0     # 0x8300
movq %rsp, %r13
movaps %xmm0, (%r13)
movabsq $0x404396ec17ebaf10, %rax # imm = 0x404396EC17EBAF10
movq %rax, 0x10(%r13)
movaps 0x4bfb(%rip), %xmm0     # 0x8330
leaq 0x80(%rsp), %r15
movaps %xmm0, 0x10(%r15)
movaps 0x4bd7(%rip), %xmm0     # 0x8320
movaps %xmm0, (%r15)
movaps 0x4bfc(%rip), %xmm0     # 0x8350
leaq 0x60(%rsp), %r14
movaps %xmm0, 0x10(%r14)
movaps 0x4bdb(%rip), %xmm0     # 0x8340
movaps %xmm0, (%r14)
pushq $0x15
popq %rdi
pushq $0x3
popq %rbx
pushq $0x4
popq %rbp
leaq 0x40(%rsp), %r12
movl %ebx, %esi
movl %ebp, %edx
movq %r12, %r9
callq 0x4b8e
pushq $0x6c
popq %r8
pushq $0x1
popq %r9
movq %r13, %rdi
movq %r12, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
movl %r9d, %r13d
callq 0x5b0f
pushq $0x16
popq %rdi
movl %ebp, %esi
movl %ebx, %edx
movq %r15, %rcx
leaq 0xa0(%rsp), %r8
movq %r12, %r9
callq 0x4b8e
pushq $0x6f
popq %r8
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
movl %r13d, %r9d
callq 0x5b0f
addq $0x108, %rsp            # imm = 0x108
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/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:
pushq %rbx
subq $0x80, %rsp
leaq -0x91(%rip), %rax       # 0x37e0
leaq 0x50(%rsp), %rdi
movq %rax, (%rdi)
leaq -0x6e(%rip), %rax       # 0x3812
movq %rax, 0x8(%rdi)
movabsq $0xa00000002, %rax      # imm = 0xA00000002
movq %rax, 0x10(%rdi)
movaps 0x4ae7(%rip), %xmm0     # 0x8380
movups %xmm0, 0x18(%rdi)
leaq 0x40(%rsp), %rax
movq %rax, 0x28(%rdi)
movaps 0x4ae3(%rip), %xmm0     # 0x8390
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps 0x4ae4(%rip), %xmm0     # 0x83a0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x10(%rsp), %rbx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x4ce0
movaps 0x4ad6(%rip), %xmm0     # 0x83b0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
pushq $0x2
popq %rdx
pushq $0x21
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5b0f
addq $0x80, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rdi), %r13
movl 0x8(%rdi), %edi
movq %rdi, 0x8(%rsp)
movq %r13, %rdx
callq 0x46fa
xorl %ebp, %ebp
movq 0x8(%rsp), %rax
testl %eax, %eax
cmovlel %ebp, %eax
movq %rax, 0x8(%rsp)
cmpq %rbp, 0x8(%rsp)
je 0x3b83
movsd 0x10(%r12), %xmm0
movsd (%r15,%rbp,8), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd (%r13,%rbp,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%r13,%rbp,8)
movq %r13, %rdi
movq %r14, %rsi
callq *(%r12)
movsd %xmm0, (%rbx,%rbp,8)
movsd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd (%r13,%rbp,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%r13,%rbp,8)
movq %r13, %rdi
movq %r14, %rsi
callq *(%r12)
movsd (%rbx,%rbp,8), %xmm1
subsd %xmm0, %xmm1
divsd 0x10(%rsp), %xmm1
movsd %xmm1, (%rbx,%rbp,8)
movsd (%r15,%rbp,8), %xmm0
movsd %xmm0, (%r13,%rbp,8)
incq %rbp
jmp 0x3ae7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %r12
pushq $-0x1
popq %rbp
incl %ebp
cmpl 0x10(%r15), %ebp
jge 0x3c11
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq *0x8(%r15)
movl 0x28(%r15), %edi
movsd 0x20(%r15), %xmm0
xorps 0x47ea(%rip), %xmm0     # 0x83c0
movq %r12, %rsi
movq %r14, %rdx
callq 0x4770
movsd 0x20(%r15), %xmm0
andpd 0x47e1(%rip), %xmm0     # 0x83d0
movapd %xmm0, (%rsp)
movl 0x28(%r15), %edi
movq %r12, %rsi
callq 0x477e
mulsd (%rsp), %xmm0
movsd 0x18(%r15), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3bb0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rax
movq %rsi, %r9
movl 0x18(%rdi), %eax
movl 0x14(%rdi), %r10d
movl 0x10(%rdi), %ecx
movq (%rdi), %r8
movq %rdx, (%rsp)
pushq $0xb
popq %rsi
movsd 0x3c50(%rip), %xmm0     # 0x7890
xorps %xmm1, %xmm1
movl %eax, %edi
movl %r10d, %edx
callq 0x4720
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/src/least_squares.c
// Function: morpheus_ls_cost_old
double morpheus_ls_cost_old(const morpheus_reg_t *reg,
                        const morpheus_data_t *data,
                        const double *theta,
                        double *m) {
  const double alpha = 1;
  const double beta = -1;

  morpheus_dcopy(data->num_examples, data->y, m);
  morpheus_dgemv(data->layout, morpheus_no_trans, data->num_examples,
                 data->num_features, alpha, data->x, theta, beta, m);
  double v = morpheus_ddot(data->num_examples, m, m);
  double reg_term = morpheus_cost_reg(reg, data->num_features, theta);
  v = (v*0.5 + reg_term) / data->num_examples;

  return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl 0x14(%rsi), %edi
movq 0x8(%rsi), %rsi
movq %rcx, %rdx
callq 0x46fa
movl 0x18(%rbx), %edi
movl 0x14(%rbx), %edx
movl 0x10(%rbx), %ecx
movq (%rbx), %r8
movq %r12, (%rsp)
pushq $0xb
popq %rsi
movsd 0x3c00(%rip), %xmm0     # 0x7890
movsd 0x3be8(%rip), %xmm1     # 0x7880
movq %r14, %r9
callq 0x4720
movl 0x14(%rbx), %edi
movq %r12, %rsi
movq %r12, %rdx
callq 0x4786
movsd %xmm0, 0x10(%rsp)
cvtsi2sdl 0x10(%rbx), %xmm0
movq %r15, %rdi
movq %r14, %rsi
callq 0x4644
movsd 0x10(%rsp), %xmm1
mulsd 0x470e(%rip), %xmm1     # 0x83e0
addsd %xmm1, %xmm0
cvtsi2sdl 0x14(%rbx), %xmm1
divsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/src/least_squares.c
// Function: morpheus_ls_gradient_old
void morpheus_ls_gradient_old(const morpheus_reg_t *reg,
                          const morpheus_data_t *data,
                          const double *theta,
                          double *grad,
                          double *m) {
  morpheus_dcopy(data->num_examples, data->y, m);
  morpheus_dgemv(data->layout, morpheus_no_trans, data->num_examples,
                 data->num_features, 1, data->x, theta, -1, m);
  morpheus_dgemv(data->layout, morpheus_trans, data->num_examples,
                 data->num_features, 1, data->x, m, 0, grad);

  double *reg_term = m;
  morpheus_gradient_reg(reg, data->num_features, theta, reg_term);
  morpheus_daxpy(data->num_features, 1, reg_term, grad);

  morpheus_dscal(data->num_features, 1.0/data->num_examples, grad);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movl 0x14(%rsi), %edi
movq 0x8(%rsi), %rsi
movq %r8, %rdx
callq 0x46fa
movl 0x18(%r14), %edi
movl 0x14(%r14), %edx
movl 0x10(%r14), %ecx
movq (%r14), %r8
movq %r15, (%rsp)
pushq $0xb
popq %rsi
movsd 0x3b5c(%rip), %xmm0     # 0x7890
movsd 0x3b44(%rip), %xmm1     # 0x7880
movq %r12, %r9
callq 0x4720
movl 0x18(%r14), %edi
movl 0x14(%r14), %edx
movl 0x10(%r14), %ecx
movq (%r14), %r8
movq %rbx, (%rsp)
pushq $0xc
popq %rsi
xorps %xmm1, %xmm1
movsd 0x3b2b(%rip), %xmm0     # 0x7890
movq %r15, %r9
callq 0x4720
cvtsi2sdl 0x10(%r14), %xmm0
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x467c
movl 0x10(%r14), %edi
movsd 0x3b03(%rip), %xmm0     # 0x7890
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4770
movl 0x10(%r14), %edi
cvtsi2sdl 0x14(%r14), %xmm1
movsd 0x3ae6(%rip), %xmm0     # 0x7890
divsd %xmm1, %xmm0
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x46f2
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/src/regularization.c
// Function: morpheus_cost_reg
double morpheus_cost_reg(const morpheus_reg_t *params,
                         const double num_features,
                         const double *theta) {
  if (params->type == morpheus_reg_l2) {
    theta = theta + 1;  /* skip the first element */
    return morpheus_ddot(num_features-1, theta, theta) * params->lambda * 0.5;
  }
  return 0;
}

// Assembly:
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
cmpl $0x1, (%rdi)
jne 0x467b
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rsi
addsd 0x321f(%rip), %xmm1     # 0x7880
cvttsd2si %xmm1, %edi
movq %rsi, %rdx
callq 0x4786
mulsd 0x8(%rbx), %xmm0
mulsd 0x3d66(%rip), %xmm0     # 0x83e0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/src/regularization.c
// Function: morpheus_gradient_reg
void morpheus_gradient_reg(const morpheus_reg_t *params,
                           const double num_features,
                           const double *theta,
                           double *reg) {
  if (params->type == morpheus_reg_l2) {
    morpheus_dcopy(num_features, theta, reg);
    morpheus_dscal(num_features, params->lambda, reg);
    reg[0] = 0;
  } else {
    for (int i = 0; i < num_features; ++i) {
      reg[i] = 0;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
cmpl $0x1, (%rdi)
jne 0x46b2
movq %rdi, %r14
cvttsd2si %xmm0, %ebp
movl %ebp, %edi
movq %rbx, %rdx
callq 0x46fa
movsd 0x8(%r14), %xmm0
movl %ebp, %edi
movq %rbx, %rsi
callq 0x46f2
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x46ad
andq $0x0, (%rbx,%rax,8)
incq %rax
jmp 0x46b4
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/src/statistics.c
// Function: morpheus_mean
double morpheus_mean(int n, const double *x) {
  double m = 0;
  for (int i = 0; i < n; ++i) {
    m += x[i];
  }
  return m/n;
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
movl $0x0, %ecx
cmovgl %edi, %ecx
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
je 0x494b
addsd (%rsi,%rax,8), %xmm0
incq %rax
jmp 0x493c
cvtsi2sd %edi, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/src/statistics.c
// Function: morpheus_stddev_m
double morpheus_stddev_m(double mean, int n, const double *x) {
  if (n < 2) return 0;

  double s = 0;
  for (int i = 0; i < n; ++i) {
    double v = x[i] - mean;
    s += v*v;
  }
  return sqrt(s/(n-1));
}

// Assembly:
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
cmpl $0x2, %edi
jl 0x499c
movl %edi, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x4980
movsd (%rsi,%rcx,8), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
jmp 0x4965
decl %edi
cvtsi2sd %edi, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1120
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/src/statistics.c
// Function: morpheus_column_stddev_m
void morpheus_column_stddev_m(morpheus_layout_e layout,
                              int nrows, int ncols,
                              const double *means,
                              const double *x,
                              double *s) {
  if (layout == morpheus_row_major) {
    for (int j = 0; j < ncols; ++j) {
      s[j] = 0;
    }
    for (int i = 0; i < nrows; ++i) {
      const double *row = x + i*ncols;
      for (int j = 0; j < ncols; ++j) {
        double v = row[j] - means[j];
        s[j] += v*v;
      }
    }
  } else if (layout == morpheus_col_major) {
    for (int j = 0; j < ncols; ++j) {
      const double *column = &x[j*nrows];
      s[j] = 0;
      for (int i = 0; i < nrows; ++i) {
        double v = column[i] - means[j];
        s[j] += v*v;
      }
    }
  } else {
    perror("unkwnown matrix layout");
    assert(0);
  }
  for (int j = 0; j < ncols; ++j) {
    s[j] = sqrt(s[j]/(nrows-1));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %rbx
cmpl $0x15, %edi
je 0x4aad
cmpl $0x16, %edi
jne 0x4b65
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %edi
cmovgl %esi, %edi
movslq %esi, %r9
testl %edx, %edx
movl %edx, %r14d
cmovlel %eax, %r14d
shlq $0x3, %r9
cmpq %r14, %rax
je 0x4b13
andq $0x0, (%rbx,%rax,8)
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rdi
je 0x4aa5
movsd (%r8,%rdx,8), %xmm1
subsd (%rcx,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rdx
jmp 0x4a83
incq %rax
addq %r9, %r8
jmp 0x4a6f
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %r14d
cmovgl %edx, %r14d
cmpq %rax, %r14
je 0x4aca
andq $0x0, (%rbx,%rax,8)
incq %rax
jmp 0x4abb
movslq %edx, %rax
xorl %edx, %edx
testl %esi, %esi
movl $0x0, %edi
cmovgl %esi, %edi
shlq $0x3, %rax
cmpq %rdi, %rdx
je 0x4b13
xorl %r9d, %r9d
cmpq %r9, %r14
je 0x4b0b
movsd (%r8,%r9,8), %xmm0
subsd (%rcx,%r9,8), %xmm0
mulsd %xmm0, %xmm0
addsd (%rbx,%r9,8), %xmm0
movsd %xmm0, (%rbx,%r9,8)
incq %r9
jmp 0x4ae5
incq %rdx
addq %rax, %r8
jmp 0x4add
decl %esi
cvtsi2sd %esi, %xmm1
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movsd %xmm1, 0x8(%rsp)
cmpq %r15, %r14
je 0x4b5b
movsd (%rbx,%r15,8), %xmm0
divsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x4b41
sqrtsd %xmm0, %xmm0
jmp 0x4b50
callq 0x1120
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm1
movsd %xmm0, (%rbx,%r15,8)
incq %r15
jmp 0x4b26
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x387c(%rip), %rdi      # 0x83e8
callq 0x1100
leaq 0x3887(%rip), %rdi      # 0x83ff
leaq 0x3b82(%rip), %rsi      # 0x8701
leaq 0x3b8c(%rip), %rcx      # 0x8712
pushq $0x51
popq %rdx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/src/statistics.c
// Function: morpheus_row_stddev_m
void morpheus_row_stddev_m(morpheus_layout_e layout,
                           int nrows, int ncols,
                           const double *means,
                           const double *x,
                           double *s) {
  if (layout == morpheus_row_major) {
    for (int i = 0; i < nrows; ++i) {
      const double *row = x + i*ncols;
      s[i] = 0;
      for (int j = 0; j < ncols; ++j) {
        double v = row[j] - means[i];
        s[i] += v*v;
      }
    }
  } else if (layout == morpheus_col_major) {
    for (int i = 0; i < nrows; ++i) {
      s[i] = 0;
    }
    for (int j = 0; j < ncols; ++j) {
      const double *column = x + j*nrows;
      for (int i = 0; i < nrows; ++i) {
        double v = column[i] - means[i];
        s[i] += v*v;
      }
    }
  } else {
    perror("unkwnown matrix layout");
    assert(0);
  }
  for (int i = 0; i < nrows; ++i) {
    s[i] = sqrt(s[i]/(ncols-1));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %rbx
cmpl $0x15, %edi
je 0x4bc5
cmpl $0x16, %edi
jne 0x4cb6
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %r14d
cmovgl %esi, %r14d
cmpq %rax, %r14
je 0x4c1b
andq $0x0, (%rbx,%rax,8)
incq %rax
jmp 0x4bb6
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %edi
cmovgl %edx, %edi
movslq %edx, %r9
testl %esi, %esi
movl %esi, %r14d
cmovlel %eax, %r14d
shlq $0x3, %r9
cmpq %r14, %rax
je 0x4c64
andq $0x0, (%rbx,%rax,8)
xorpd %xmm0, %xmm0
xorl %esi, %esi
cmpq %rsi, %rdi
je 0x4c13
movsd (%r8,%rsi,8), %xmm1
subsd (%rcx,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rsi
jmp 0x4bf1
incq %rax
addq %r9, %r8
jmp 0x4be1
movslq %esi, %rax
xorl %esi, %esi
testl %edx, %edx
movl $0x0, %edi
cmovgl %edx, %edi
shlq $0x3, %rax
cmpq %rdi, %rsi
je 0x4c64
xorl %r9d, %r9d
cmpq %r9, %r14
je 0x4c5c
movsd (%r8,%r9,8), %xmm0
subsd (%rcx,%r9,8), %xmm0
mulsd %xmm0, %xmm0
addsd (%rbx,%r9,8), %xmm0
movsd %xmm0, (%rbx,%r9,8)
incq %r9
jmp 0x4c36
incq %rsi
addq %rax, %r8
jmp 0x4c2e
decl %edx
cvtsi2sd %edx, %xmm1
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movsd %xmm1, 0x8(%rsp)
cmpq %r15, %r14
je 0x4cac
movsd (%rbx,%r15,8), %xmm0
divsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x4c92
sqrtsd %xmm0, %xmm0
jmp 0x4ca1
callq 0x1120
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm1
movsd %xmm0, (%rbx,%r15,8)
incq %r15
jmp 0x4c77
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x372b(%rip), %rdi      # 0x83e8
callq 0x1100
leaq 0x3736(%rip), %rdi      # 0x83ff
leaq 0x3a31(%rip), %rsi      # 0x8701
leaq 0x3aa0(%rip), %rcx      # 0x8777
pushq $0x73
popq %rdx
callq 0x1070
nop
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/external/Unity/unity.c
// Function: UnityPrint
void UnityPrint(const char* string)
{
    const char* pch = string;

    if (pch != NULL)
    {
        while (*pch)
        {
            /* printable characters plus CR & LF are printed */
            if ((*pch <= 126) && (*pch >= 32))
            {
                UNITY_OUTPUT_CHAR(*pch);
            }
            /* write escaped carriage returns */
            else if (*pch == 13)
            {
                UNITY_OUTPUT_CHAR('\\');
                UNITY_OUTPUT_CHAR('r');
            }
            /* write escaped line feeds */
            else if (*pch == 10)
            {
                UNITY_OUTPUT_CHAR('\\');
                UNITY_OUTPUT_CHAR('n');
            }
            /* unprintable characters are shown as codes */
            else
            {
                UNITY_OUTPUT_CHAR('\\');
                UNITY_OUTPUT_CHAR('x');
                UnityPrintNumberHex((UNITY_UINT)*pch, 2);
            }
            pch++;
        }
    }
}

// Assembly:
testq %rdi, %rdi
je 0x4f35
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x5c
popq %rbp
pushq $0x72
popq %r15
pushq $0x78
popq %r12
pushq $0x2
popq %r13
movzbl (%rbx), %r14d
testl %r14d, %r14d
je 0x4f27
leal -0x20(%r14), %eax
cmpb $0x5e, %al
ja 0x4eec
movl %r14d, %edi
jmp 0x4f07
movl %ebp, %edi
callq 0x1080
cmpl $0xa, %r14d
je 0x4f04
cmpl $0xd, %r14d
jne 0x4f11
movl %r15d, %edi
jmp 0x4f07
pushq $0x6e
popq %rdi
callq 0x1080
incq %rbx
jmp 0x4ed6
movl %r12d, %edi
callq 0x1080
movsbq (%rbx), %rdi
movl %r13d, %esi
callq 0x4f36
jmp 0x4f0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/external/Unity/unity.c
// Function: UnityPrintNumber
void UnityPrintNumber(const UNITY_INT number_to_print)
{
    UNITY_UINT number = (UNITY_UINT)number_to_print;

    if (number_to_print < 0)
    {
        /* A negative number, including MIN negative */
        UNITY_OUTPUT_CHAR('-');
        number = (UNITY_UINT)(-number_to_print);
    }
    UnityPrintNumberUnsigned(number);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
jns 0x5080
pushq $0x2d
popq %rdi
callq 0x1080
negq %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x5089
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/external/Unity/unity.c
// Function: UnityPrintDecimalAndNumberWithLeadingZeros
static void UnityPrintDecimalAndNumberWithLeadingZeros(UNITY_INT32 fraction_part, UNITY_INT32 divisor)
{
    UNITY_OUTPUT_CHAR('.');
    while (divisor > 0)
    {
        UNITY_OUTPUT_CHAR('0' + fraction_part / divisor);
        fraction_part %= divisor;
        divisor /= 10;
        if (fraction_part == 0) break; /* Truncate trailing 0's */
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
pushq $0x2e
popq %rdi
callq 0x1080
pushq $0xa
popq %r14
movl %ebp, %eax
cltd
idivl %ebx
leal 0x30(%rax), %edi
movl %edx, %ebp
callq 0x1080
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
cmpl $0xa, %ebx
jl 0x536e
movl %eax, %ebx
testl %ebp, %ebp
jne 0x534d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/external/Unity/unity.c
// Function: UnityConcludeTest
void UnityConcludeTest(void)
{
    if (Unity.CurrentTestIgnored)
    {
        Unity.TestIgnores++;
    }
    else if (!Unity.CurrentTestFailed)
    {
        UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber);
        UnityPrint(UnityStrPass);
    }
    else
    {
        Unity.TestFailures++;
    }

    Unity.CurrentTestFailed = 0;
    Unity.CurrentTestIgnored = 0;
    UNITY_PRINT_EOL();
    UNITY_FLUSH_CALL();
}

// Assembly:
cmpq $0x0, 0x7d95(%rip)      # 0xd110
je 0x5386
incq 0x7d7c(%rip)            # 0xd100
jmp 0x53bd
cmpq $0x0, 0x7d7a(%rip)      # 0xd108
je 0x5399
incq 0x7d61(%rip)            # 0xd0f8
jmp 0x53bd
pushq %rax
movq 0x7d27(%rip), %rdi      # 0xd0c8
movq 0x7d40(%rip), %rsi      # 0xd0e8
callq 0x53cf
leaq 0x3557(%rip), %rdi      # 0x890b
callq 0x4eb4
addq $0x8, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x7d41(%rip)     # 0xd108
pushq $0xa
popq %rdi
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/external/Unity/unity.c
// Function: UnityAssertEqualDoubleArray
void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected,
                                 UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual,
                                 const UNITY_UINT32 num_elements,
                                 const char* msg,
                                 const UNITY_LINE_TYPE lineNumber,
                                 const UNITY_FLAGS_T flags)
{
    UNITY_UINT32 elements = num_elements;
    UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_expected = expected;
    UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_actual = actual;

    RETURN_IF_FAIL_OR_IGNORE;

    if (elements == 0)
    {
        UnityPrintPointlessAndBail();
    }

    if (expected == actual) return; /* Both are NULL or same pointer */
    if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg))
        UNITY_FAIL_AND_BAIL;

    while (elements--)
    {
        if (!UnityDoublesWithin(*ptr_expected * UNITY_DOUBLE_PRECISION, *ptr_expected, *ptr_actual))
        {
            UnityTestResultsFailBegin(lineNumber);
            UnityPrint(UnityStrElement);
            UnityPrintNumberUnsigned(num_elements - elements - 1);
            UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(*ptr_expected, *ptr_actual);
            UnityAddMsgIfSpecified(msg);
            UNITY_FAIL_AND_BAIL;
        }
        if (flags == UNITY_ARRAY_TO_ARRAY)
        {
            ptr_expected++;
        }
        ptr_actual++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq 0x75eb(%rip), %rax      # 0xd110
orq 0x75dc(%rip), %rax      # 0xd108
jne 0x5ba1
movq %r8, %r12
movl %edx, %ebp
testl %edx, %edx
je 0x5c1c
movq %rsi, %r14
movq %rdi, %r15
cmpq %rsi, %rdi
je 0x5ba1
movl %r9d, %r13d
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq (%rsp), %rcx
callq 0x5763
testl %eax, %eax
jne 0x5c02
xorl %ebx, %ebx
cmpl $0x1, %r13d
sete %bl
shll $0x3, %ebx
movl %ebp, %ebp
xorl %r13d, %r13d
cmpl %r13d, %ebp
je 0x5ba1
movsd (%r15), %xmm1
movapd %xmm1, %xmm0
mulsd 0x2ca6(%rip), %xmm0     # 0x8830
movsd (%r14,%r13,8), %xmm2
callq 0x5c32
testl %eax, %eax
je 0x5bb0
addq %rbx, %r15
incq %r13
jmp 0x5b74
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x549f
leaq 0x2da8(%rip), %rdi      # 0x8967
callq 0x4eb4
movq %r13, %rdi
callq 0x5089
leaq 0x2d3d(%rip), %rdi      # 0x8910
callq 0x4eb4
movsd (%r15), %xmm0
callq 0x5133
leaq 0x2d32(%rip), %rdi      # 0x891b
callq 0x4eb4
movsd (%r14,%r13,8), %xmm0
callq 0x5133
movq (%rsp), %rdi
callq 0x54c4
movq $0x1, 0x74fb(%rip) # 0xd108
leaq 0x7504(%rip), %rdi      # 0xd118
pushq $0x1
popq %rsi
callq 0x10d0
movq %r12, %rdi
callq 0x549f
leaq 0x2d05(%rip), %rdi      # 0x8930
callq 0x4eb4
jmp 0x5bf9
// File: /workspace/github_c_makefile_star2_O2/aligusnet[P]morpheus/external/Unity/unity.c
// Function: UnityAssertDoublesWithin
void UnityAssertDoublesWithin(const UNITY_DOUBLE delta,
                              const UNITY_DOUBLE expected,
                              const UNITY_DOUBLE actual,
                              const char* msg,
                              const UNITY_LINE_TYPE lineNumber)
{
    RETURN_IF_FAIL_OR_IGNORE;

    if (!UnityDoublesWithin(delta, expected, actual))
    {
        UnityTestResultsFailBegin(lineNumber);
        UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual);
        UnityAddMsgIfSpecified(msg);
        UNITY_FAIL_AND_BAIL;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x742e(%rip), %rax      # 0xd110
orq 0x741f(%rip), %rax      # 0xd108
jne 0x5d12
movq %rsi, %r14
movq %rdi, %rbx
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
movsd %xmm2, 0x10(%rsp)
movsd 0x10(%rsp), %xmm2
callq 0x5c32
testl %eax, %eax
je 0x5d1a
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x549f
leaq 0x2be7(%rip), %rdi      # 0x8910
callq 0x4eb4
movsd 0x8(%rsp), %xmm0
callq 0x5133
leaq 0x2bdb(%rip), %rdi      # 0x891b
callq 0x4eb4
movsd 0x10(%rsp), %xmm0
callq 0x5133
movq %rbx, %rdi
callq 0x54c4
movq $0x1, 0x73a5(%rip) # 0xd108
leaq 0x73ae(%rip), %rdi      # 0xd118
pushq $0x1
popq %rsi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/icepole256av2/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
	unsigned char *c,unsigned long long *clen,
	const unsigned char *m,unsigned long long mlen,
	const unsigned char *ad,unsigned long long adlen,
	const unsigned char *nsec,
	const unsigned char *npub,
	const unsigned char *k )
{
    ICESTATE S;
    unsigned int frameBit;
    
    /* initialize the state with secret key and nonce */
    initState256a(S, k, npub);

    /* ciphertext length is plaintext len + size of tag and nsec */
    *clen = mlen + ICEPOLETAGLEN; 
    
    /* secret message number is zero length */
    processDataBlock(S, NULL, NULL, 0, 0);
    
    /* process auth-only associated data blocks */
    do {
        unsigned long long blocklen = ICEPOLEDATABLOCKLEN;
        frameBit = (adlen <= blocklen ? 1 : 0); /* is it the last block? */
        if (adlen < blocklen) {
            blocklen = adlen;
        }
        /* apply the permutation to the state */
        P6(S,S);
        /* absorb a data block */
        processDataBlock(S, ad, NULL, blocklen, frameBit);
        ad += blocklen;
        adlen -= blocklen;
    } while (adlen > 0);

    /* process plaintext blocks to get the ciphertext */
    do {
        unsigned long long blocklen = ICEPOLEDATABLOCKLEN;
        frameBit = (mlen <=blocklen ? 0 : 1);
        if (mlen < blocklen) {
            blocklen = mlen;
        }
        /* apply the permutation to the state */
        P6(S,S);
        /* absorb a data block and produce a ciphertext block */
        processDataBlock(S, m, &c, blocklen, frameBit);
        m += blocklen;
        mlen -= blocklen;    
    } while (mlen > 0);

    /* store authentication tag at the end of the ciphertext */
    generateTag(S, c);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movq %rsi, %rbp
movq 0x100(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq %rdi, (%rsp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1030
leaq 0x10(%rbx), %rax
movq %rax, (%rbp)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1060
pushq $0x78
popq %rax
xorl %ebp, %ebp
cmpq $0x79, %r15
setb %bpl
cmpq $0x78, %r15
movq %rax, %r14
movq %rax, %r13
cmovbq %r15, %r13
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
callq 0x1110
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x1060
addq %r13, %r12
subq %r13, %r15
movq %r14, %rax
jne 0x128b
leaq 0x10(%rsp), %r15
movq 0x8(%rsp), %r12
xorl %ebp, %ebp
cmpq $0x79, %rbx
setae %bpl
cmpq $0x78, %rbx
movq %r14, %r13
cmovbq %rbx, %r13
movq %r15, %rdi
movq %r15, %rsi
callq 0x1110
movq %r15, %rdi
movq %r12, %rsi
movq %rsp, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x1060
addq %r13, %r12
subq %r13, %rbx
jne 0x12da
movq (%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x10f0
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/data.h
// Function: tino_data_file_readI
static int
tino_data_file_readI(TINO_DATA *d, void *ptr, size_t max)
{
  int	n;

  n	= tino_file_readI(d->user.fd, ptr, max);
  if (n<0 && errno!=EINTR)
    {
      tino_data_error(d, "file read error fd %d", d->user.fd);
      n	= 0;
    }
  return n;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x28(%rdi), %edi
callq 0x4608
movl %eax, %ebp
testl %eax, %eax
jns 0x24b4
callq 0x2060
cmpl $0x4, (%rax)
je 0x24b4
movl 0x28(%rbx), %edx
leaq 0x6a03(%rip), %rsi      # 0x8eab
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x461e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/data.h
// Function: tino_data_file_writeI
static int
tino_data_file_writeI(TINO_DATA *d, const void *ptr, size_t max)
{
  int	n;

  n	= tino_file_writeI(d->user.fd, ptr, max);
  if (n<0 && errno!=EINTR)
    {
      tino_data_error(d, "file write error fd %d", d->user.fd);
      n	= 0;
    }
  return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x28(%rdi), %edi
callq 0x20d0
movq %rax, %r14
testl %r14d, %r14d
jns 0x24f5
callq 0x2060
cmpl $0x4, (%rax)
je 0x24f5
movl 0x28(%rbx), %edx
leaq 0x69e3(%rip), %rsi      # 0x8ecb
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x461e
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/data.h
// Function: tino_data_file_syncA
static int
tino_data_file_syncA(TINO_DATA *d, int sync)
{
  if (sync && tino_file_flush_fdE(d->user.fd))
    {
      tino_data_error(d, "file flush error fd %d", d->user.fd);
      return -1;
    }
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testl %esi, %esi
je 0x252f
movq %rdi, %rbx
movl 0x28(%rdi), %edi
callq 0x2070
testl %eax, %eax
je 0x252f
movl 0x28(%rbx), %edx
leaq 0x69c0(%rip), %rsi      # 0x8ee2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x461e
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/data.h
// Function: tino_data_size_genericA
static tino_file_size_t
tino_data_size_genericA(TINO_DATA *d)
{
  tino_file_size_t	pos, len;

  if (!d || !d->handler || !d->handler->seek_end)
    {
      tino_data_error(d, "cannot seek to get size");
      return 0;
    }
  pos	= tino_data_posA(d);
  len	= tino_data_seek_endA(d);
  tino_data_seekA(d, pos);
  return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2586
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x2586
cmpq $0x0, 0x38(%rax)
je 0x2586
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x25a3
movq %rbx, %rdi
callq *%rax
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x25b7
pushq $-0x1
popq %r14
leaq 0x699d(%rip), %rsi      # 0x8f21
jmp 0x25ad
leaq 0x696c(%rip), %rsi      # 0x8ef9
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x461e
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6967(%rip), %rsi      # 0x8f11
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x461e
movq 0x20(%rbx), %rax
leaq 0x6973(%rip), %rsi      # 0x8f35
testq %rax, %rax
je 0x25eb
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x25eb
movq %rbx, %rdi
callq *%rax
movq %rax, %r15
cmpq $-0x1, %rax
jne 0x25f8
pushq $-0x1
popq %r15
leaq 0x6961(%rip), %rsi      # 0x8f4a
jmp 0x25ee
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x461e
movq 0x20(%rbx), %rax
leaq 0x695c(%rip), %rsi      # 0x8f5f
testq %rax, %rax
je 0x2590
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x2590
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
cmpq %r14, %rax
je 0x259a
leaq 0x6943(%rip), %rsi      # 0x8f70
jmp 0x2590
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/buf.h
// Function: tino_buf_add_nO
static void
tino_buf_add_nO(TINO_BUF *buf, const void *ptr, size_t len)
{
  tino_FATAL(!ptr);

  cDP(("(%p,%p,%ld)", buf, ptr, (long)len));
  memcpy(tino_buf_add_ptrO(buf, len), ptr, len);
  buf->fill	+= len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x4024
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rsi
callq 0x4055
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2200
addq %rbx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4dbe(%rip), %rdi      # 0x8de9
leaq 0x4dbc(%rip), %rsi      # 0x8dee
leaq 0x4dc2(%rip), %rcx      # 0x8dfb
movl $0x128, %edx            # imm = 0x128
callq 0x4043
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/buf.h
// Function: tino_buf_add_ptrO
TINO_INLINE(static char *
tino_buf_add_ptrO(TINO_BUF *buf, size_t len))
{
  tino_FATAL(!buf);

  cDP(("(%p,%ld)", buf, (long)len));
  if (buf->fill+len>=buf->max)
    tino_buf_extendO(buf, buf->fill+len-buf->max+1);
  return buf->data+buf->fill;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x407e
movq %rdi, %rbx
movq (%rdi), %rax
addq %rax, %rsi
subq 0x8(%rdi), %rsi
jb 0x4078
incq %rsi
movq %rbx, %rdi
callq 0x42c9
movq (%rbx), %rax
addq 0x18(%rbx), %rax
popq %rbx
retq
leaq 0x4d9f(%rip), %rdi      # 0x8e24
leaq 0x4d62(%rip), %rsi      # 0x8dee
leaq 0x4d96(%rip), %rcx      # 0x8e29
movl $0x11b, %edx            # imm = 0x11B
callq 0x4043
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/ex.h
// Function: tino_verror_ext
static void
tino_verror_ext(TINO_VA_LIST list, int err, const char *prefix, ...)
{
  tino_va_list	list2;

  tino_va_start(list2, prefix);
  tino_verror_vext(&list2, list, err);
  tino_va_end(list2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x20(%rsp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x41e3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdx, (%rsp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, 0x8(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x8dc1(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
callq 0x2220
cmpq $0x0, (%rsp)
jne 0x4257
movq 0x8dd3(%rip), %r15      # 0xcff8
movq (%r15), %rdi
movq %r14, %rsi
callq 0x429d
movq (%r15), %r14
testl %ebx, %ebx
jne 0x4280
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x2190
movq (%r15), %rdi
callq 0x2220
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8d9a(%rip), %r15      # 0xcff8
movq (%r15), %rdi
movq %rsp, %rsi
callq 0x429d
movq (%r15), %rcx
leaq 0x4c35(%rip), %rdi      # 0x8ea8
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x22b0
jmp 0x421e
movl %ebx, %edi
callq 0x22d0
leaq 0x5457(%rip), %rsi      # 0x96e5
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21d0
jmp 0x4242
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/buf.h
// Function: tino_buf_extendO
static void
tino_buf_extendO(TINO_BUF *buf, size_t len)
{
  tino_FATAL(!buf);

  cDP(("(%p,%ld) p=%p l=%ld m=%ld p=%ld", buf, (long)len,
      buf->data, (long)buf->fill, (long)buf->max, (long)buf->off));
  if (!len)
    return;
  if (buf->off>=len)
    {
      tino_FATAL(buf->fill<buf->off);
      if ((buf->fill-=buf->off)!=0)
	memmove(buf->data, buf->data+buf->off, buf->fill);
      buf->off	= 0;
    }
  else
    {
      buf->max	+= len;
      buf->data	=  (char *)tino_reallocO(buf->data, buf->max);
    }
  cDP(("() %p", buf->data));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4346
movq %rsi, %r14
testq %rsi, %rsi
je 0x4340
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
cmpq %r14, %rsi
jae 0x4302
addq 0x8(%rbx), %r14
movq %r14, 0x8(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4322
movq %r14, %rsi
callq 0x2230
jmp 0x432a
movq (%rbx), %rdx
subq %rsi, %rdx
jb 0x435f
movq %rdx, (%rbx)
je 0x431b
movq 0x18(%rbx), %rdi
addq %rdi, %rsi
callq 0x2260
andq $0x0, 0x10(%rbx)
jmp 0x4340
movq %r14, %rdi
callq 0x2210
movq %rax, %r15
testq %rax, %rax
jne 0x433c
movq %r14, %rsi
xorl %eax, %eax
callq 0x437c
movq %r15, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4ad7(%rip), %rdi      # 0x8e24
leaq 0x4a9a(%rip), %rsi      # 0x8dee
leaq 0x4ae0(%rip), %rcx      # 0x8e3b
pushq $0x42
jmp 0x4376
leaq 0x4ae6(%rip), %rdi      # 0x8e4c
leaq 0x4a81(%rip), %rsi      # 0x8dee
leaq 0x4ac7(%rip), %rcx      # 0x8e3b
pushq $0x4a
popq %rdx
callq 0x4043
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/data.h
// Function: tino_data_error
static void
tino_data_error(TINO_DATA *d, const char *s, ...)
{
  tino_va_list	list;

  tino_va_start(list, s);
  if (d && d->err)
    d->err(d, &list);
  else
    tino_vpexit((d->handler ? d->handler->type : "tino_data"), &list);
  tino_va_end(list);
}

// Assembly:
subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x4675
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, (%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, 0x8(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r10, 0x18(%rsp)
testq %rdi, %rdi
je 0x46b5
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x46b5
movq %rsp, %rsi
callq *%rax
addq $0xd8, %rsp
retq
movq 0x20(%rdi), %rax
testq %rax, %rax
jne 0x46c7
leaq 0x47fc(%rip), %rsi      # 0x8ec1
jmp 0x46ca
movq (%rax), %rsi
movq %rsp, %rdx
xorl %edi, %edi
callq 0x46d4
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/ex.h
// Function: tino_vpexit_n
static void
tino_vpexit_n(int n, const char *prefix, TINO_VA_LIST list)
{
  tino_verror(prefix, list, errno);
  if (n==0)
    n = tino_exit_default_code;
  TINO_ABORT(n);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
callq 0x2060
movl (%rax), %edx
movq 0x8bc2(%rip), %rax      # 0xd2b0
testq %rax, %rax
leaq -0x598(%rip), %rcx      # 0x4160
cmovneq %rax, %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq *%rcx
testl %ebp, %ebp
movzbl 0x8b9f(%rip), %edi      # 0xd2ac
notl %edi
cmovnel %ebp, %edi
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/main.h
// Function: tino_main_verror_fn
static void
tino_main_verror_fn(const char *prefix, TINO_VA_LIST list, int err)
{
  int	tmp;

  tmp			= *tino_main_errflag;
  *tino_main_errflag	= 3;	/* We are in the error routine	*/

  tino_verror_std(prefix, list, err);
  if (tmp<0)
    exit(-tmp);

  /* Switch in error mode
   */
  *tino_main_errflag	= tmp ? tmp : 2;
}

// Assembly:
pushq %rbx
movq 0x8b6f(%rip), %rax      # 0xd2b8
movl (%rax), %ebx
movl $0x3, (%rax)
callq 0x4160
testl %ebx, %ebx
js 0x476b
pushq $0x2
popq %rax
cmovel %eax, %ebx
movq 0x8b51(%rip), %rax      # 0xd2b8
movl %ebx, (%rax)
popq %rbx
retq
negl %ebx
movl %ebx, %edi
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/getopt.h
// Function: tino_getopt_var_set_arg
static int
tino_getopt_var_set_arg(struct tino_getopt_impl *p, const char *arg, const char *next, int invert)
{
  int		n;
  const char	*s;

  n			= 1;
  p->DEFAULT_var	= 0;
  p->NODEFAULT_var	= 0;
  if (!arg || (!*arg && !p->DIRECT_var))
    {
      n		= 2;
      arg	= next;
      if (!arg)
        arg	= "";
      if (invert<0)
        invert	= 0;
    }
  else if ((p->LLOPT_var || p->LOPT_var || p->DD_var) && *arg)
    {
      /* Long options have --"long"=arg or --"long."arg or --"long arg"
       * (--"long" "arg" has !*arg).
       * --long above can be +long on PLUS LLOPT or -long on LOPT
       *
       * In case of PLUS_var on _FLAG we see invert==-1, in this case
       * (and only in this) the next character can be '+' to invert.
       */
      if (isalnum(p->opt[p->optlen-1]))	/* option ends on AlNum	*/
        {
          /* skip next character, which must be a separator	*/
          if (*arg++!='+')		/* keep invert on --long+ or +long+ (latter can't happen)	*/
            invert	= 0;
        }
      else if (invert<0 && *arg=='+')	/* --_long_+ or --long.+ or similar	*/
        arg++;
      else
        invert	= 0;
    }
  else
    invert	= 0;
  n	= tino_getopt_var_set_arg_imp(p, arg, n, invert);
  if (n<0 || !p->FN_var)
    return n;

  s	= p->FN_var(p->varptr, arg, p->opt, p->USER_var);
  if (!s)
    return n;

  if (*s)
    fprintf(stderr, "getopt: rejected option %.*s: %s\n", p->optlen, p->opt, s);
  return -2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movq %rdi, %rbx
andq $0x0, 0x50(%rdi)
testq %rsi, %rsi
je 0x67d3
movq %rsi, %r14
movb (%rsi), %r12b
testb %r12b, %r12b
jne 0x6786
cmpl $0x0, 0x70(%rbx)
je 0x67d3
cmpl $0x0, 0x6c(%rbx)
pushq $0x1
popq %rbp
jne 0x6799
cmpl $0x0, 0x68(%rbx)
je 0x684b
testb %r12b, %r12b
je 0x67ef
callq 0x2310
movq (%rax), %rax
movq 0x40(%rbx), %rcx
movslq 0x48(%rbx), %rdx
movsbq -0x1(%rcx,%rdx), %rcx
testb $0x8, (%rax,%rcx,2)
jne 0x67f3
cmpb $0x2b, %r12b
sete %al
testl %r15d, %r15d
sets %cl
andb %al, %cl
movzbl %cl, %ecx
addq %rcx, %r14
negl %ecx
jmp 0x6800
testq %rdx, %rdx
leaq 0x29e7(%rip), %r14      # 0x91c4
cmovneq %rdx, %r14
xorl %ecx, %ecx
testl %r15d, %r15d
cmovgl %r15d, %ecx
pushq $0x2
popq %rbp
jmp 0x6800
xorl %ecx, %ecx
jmp 0x6800
incq %r14
xorl %ecx, %ecx
cmpb $0x2b, %r12b
cmovel %r15d, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x58d1
movl %eax, %ebp
testl %eax, %eax
js 0x6840
movq 0xa0(%rbx), %rax
testq %rax, %rax
je 0x6840
movq 0x8(%rbx), %rdi
movq 0x40(%rbx), %rdx
movq 0x98(%rbx), %rcx
movq %r14, %rsi
callq *%rax
testq %rax, %rax
je 0x6840
pushq $-0x2
popq %rbp
cmpb $0x0, (%rax)
jne 0x685e
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
testb %r12b, %r12b
je 0x6800
cmpl $0x0, 0x74(%rbx)
jne 0x679e
jmp 0x6800
movq 0x6793(%rip), %rcx      # 0xcff8
movq (%rcx), %rdi
movl 0x48(%rbx), %edx
movq 0x40(%rbx), %rcx
leaq 0x30a3(%rip), %rsi      # 0x9919
movq %rax, %r8
xorl %eax, %eax
callq 0x21d0
jmp 0x6840
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/getopt.h
// Function: tino_getopt_print_option_name
static void
tino_getopt_print_option_name(struct tino_getopt_impl *q, int full, const char *suffix)
{
  if (!q->DD_var)
    {
      if (q->LLOPT_var)
        fputc('-', stderr);
      fputc('-', stderr);
    }
  if (full)
    fprintf(stderr, "%s", q->opt);
  else
    fprintf(stderr, "%.*s", q->optlen, q->opt);
  if (suffix)
    fprintf(stderr, "%s", suffix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x0, 0x74(%rdi)
jne 0x68c2
cmpl $0x0, 0x6c(%r14)
je 0x68b0
movq 0x6753(%rip), %rax      # 0xcff8
movq (%rax), %rsi
pushq $0x2d
popq %rdi
callq 0x2190
movq 0x6741(%rip), %rax      # 0xcff8
movq (%rax), %rsi
pushq $0x2d
popq %rdi
callq 0x2190
movq 0x672f(%rip), %r15      # 0xcff8
movq (%r15), %rax
testl %ebp, %ebp
jne 0x68eb
movl 0x48(%r14), %edx
movq 0x40(%r14), %rcx
leaq 0x30a5(%rip), %rsi      # 0x9984
movq %rax, %rdi
xorl %eax, %eax
callq 0x21d0
jmp 0x68f7
movq 0x40(%r14), %rdi
movq %rax, %rsi
callq 0x2150
testq %rbx, %rbx
jne 0x6907
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2150