LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_matrix_reduce.c
// Function: bench_column_max_index
void bench_column_max_index(int n, const char *message,
                            morpheus_layout_e layout,
                            int size, double *x) {
  double *y = calloc(size, sizeof(double));
  int *is = calloc(size, sizeof(int));
  double start = get_time();
  for (int i = 0; i < n; ++i) {
    y[0] = i;
    morpheus_column_max_index(layout, size, size, x, y, is);
  }
  double finish = get_time();
  free(y);
  free(is);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms\n", message, ms);

}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movslq 0x40(%rsp), %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x30(%rsp)
movslq 0x40(%rsp), %rdi
movl $0x4, %esi
callq 0x10e0
movq %rax, 0x28(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x54(%rsp), %eax
jge 0x199d
cvtsi2sdl 0x1c(%rsp), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, (%rax)
movl 0x44(%rsp), %edi
movl 0x40(%rsp), %esi
movl 0x40(%rsp), %edx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
callq 0x2db0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1957
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1090
movq 0x28(%rsp), %rdi
callq 0x1090
movsd 0x10(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
cvtsi2sdl 0x54(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
leaq 0x3618(%rip), %rdi      # 0x5004
movb $0x1, %al
callq 0x1030
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_matrix_reduce.c
// Function: bench_column_min_index
void bench_column_min_index(int n, const char *message,
                            morpheus_layout_e layout,
                            int size, double *x) {
  double *y = calloc(size, sizeof(double));
  int *is = calloc(size, sizeof(int));
  double start = get_time();
  for (int i = 0; i < n; ++i) {
    y[0] = i;
    morpheus_column_min_index(layout, size, size, x, y, is);
  }
  double finish = get_time();
  free(y);
  free(is);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms\n", message, ms);
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movslq 0x40(%rsp), %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x30(%rsp)
movslq 0x40(%rsp), %rdi
movl $0x4, %esi
callq 0x10e0
movq %rax, 0x28(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x54(%rsp), %eax
jge 0x1a9d
cvtsi2sdl 0x1c(%rsp), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, (%rax)
movl 0x44(%rsp), %edi
movl 0x40(%rsp), %esi
movl 0x40(%rsp), %edx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
callq 0x3010
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1a57
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1090
movq 0x28(%rsp), %rdi
callq 0x1090
movsd 0x10(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
cvtsi2sdl 0x54(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
leaq 0x3518(%rip), %rdi      # 0x5004
movb $0x1, %al
callq 0x1030
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_matrix_reduce.c
// Function: bench_column_sum
void bench_column_sum(int n, const char *message,
                      morpheus_layout_e layout,
                      int size, double *x) {
  double *y = calloc(size, sizeof(double));
  double start = get_time();
  for (int i = 0; i < n; ++i) {
    y[0] = i;
    morpheus_column_sum(layout, size, size, x, y);
  }
  double finish = get_time();
  free(y);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms\n", message, ms);
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movslq 0x30(%rsp), %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x1d84
cvtsi2sdl 0x14(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
movl 0x34(%rsp), %edi
movl 0x30(%rsp), %esi
movl 0x30(%rsp), %edx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x3710
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1d43
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1090
movsd 0x8(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
cvtsi2sdl 0x44(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x38(%rsp), %rsi
movsd (%rsp), %xmm0
leaq 0x323d(%rip), %rdi      # 0x5004
movb $0x1, %al
callq 0x1030
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_simple_blas.c
// Function: bench_morpheus_identity
void bench_morpheus_identity(int n, const char *message, int size) {
  double *x = calloc(size*size, sizeof(double));

  double start = get_time();
  for (int i = 0; i < n; ++i) {
    x[0] = i;
    morpheus_identity(size, x);
  }
  double finish = get_time();
  free(x);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms\n", message, ms);
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl 0x34(%rsp), %eax
imull 0x34(%rsp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x28(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x1f35
cvtsi2sdl 0x1c(%rsp), %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
callq 0x4020
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1f01
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1090
movsd 0x10(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
cvtsi2sdl 0x44(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
leaq 0x308a(%rip), %rdi      # 0x5004
movb $0x1, %al
callq 0x1030
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_simple_blas.c
// Function: manual_identity
void manual_identity(int n, double *x) {
  int m = n*n;
  for (int i = 0; i < n; ++i) {
    double *row = x + i*n;
    for (int j = 0; j < n; ++j) {
      row[j] = i != j ? 0 : 1;
    }
  }
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl -0x4(%rsp), %eax
imull -0x4(%rsp), %eax
movl %eax, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x4(%rsp), %eax
jge 0x202a
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
imull -0x4(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x4(%rsp), %eax
jge 0x201b
movl -0x18(%rsp), %edx
movl -0x24(%rsp), %esi
movl $0x1, %eax
xorl %ecx, %ecx
cmpl %esi, %edx
cmovnel %ecx, %eax
cvtsi2sd %eax, %xmm0
movq -0x20(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x1fdd
jmp 0x201d
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x1fae
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_simple_blas.c
// Function: bench_manual_identity
void bench_manual_identity(int n, const char *message, int size) {
  double *x = calloc(size*size, sizeof(double));

  double start = get_time();
  for (int i = 0; i < n; ++i) {
    x[0] = i;
    manual_identity(size, x);
  }
  double finish = get_time();
  free(x);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms\n", message, ms);
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl 0x34(%rsp), %eax
imull 0x34(%rsp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x28(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x20a5
cvtsi2sdl 0x1c(%rsp), %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
callq 0x1f90
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2071
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1090
movsd 0x10(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
cvtsi2sdl 0x44(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
leaq 0x2f1a(%rip), %rdi      # 0x5004
movb $0x1, %al
callq 0x1030
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_simple_blas.c
// Function: bench_morpheus_dcopy
void bench_morpheus_dcopy(int n, const char *message, int size, double *x) {
  double *y = calloc(size*size, sizeof(double));
  double start = get_time();
  for (int i = 0; i < n; ++i) {
    y[0] = i;
    morpheus_dcopy(size*size, x, y);
  }
  double finish = get_time();
  free(y);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms\n", message, ms);
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movl 0x34(%rsp), %eax
imull 0x34(%rsp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x2184
cvtsi2sdl 0x14(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
movl 0x34(%rsp), %edi
imull 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x3b50
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2146
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1090
movsd 0x8(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
cvtsi2sdl 0x44(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x38(%rsp), %rsi
movsd (%rsp), %xmm0
leaq 0x2e3d(%rip), %rdi      # 0x5004
movb $0x1, %al
callq 0x1030
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/benchmarks/bench_simple_blas.c
// Function: bench_manual_dcopy
void bench_manual_dcopy(int n, const char *message, int size, double *x) {
  double *y = calloc(size*size, sizeof(double));
  double k = 0;
  double start = get_time();
  for (int i = 0; i < n; ++i) {
    k += y[0];
    manual_dcopy(size*size, x, y);
  }
  double finish = get_time();
  free(y);
  double ms = (finish-start)/n;
  printf("Benchmark %s: %f ms (_hack: %5.2f)\n", message, ms, k);
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movl 0x44(%rsp), %eax
imull 0x44(%rsp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x10e0
movq %rax, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x54(%rsp), %eax
jge 0x22c3
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x44(%rsp), %edi
imull 0x44(%rsp), %edi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x21e0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x227f
movb $0x0, %al
callq 0x2320
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1090
movsd 0x10(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
cvtsi2sdl 0x54(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
leaq 0x2d0b(%rip), %rdi      # 0x5019
movb $0x2, %al
callq 0x1030
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/matrix_reduce.c
// Function: morpheus_column_predicate
void morpheus_column_predicate(double (*pred)(double, double),
                               morpheus_layout_e layout,
                               int nrows,
                               int ncols,
                               const double *x,
                               double *y) {
  if (layout == morpheus_row_major) {
    /* first row is initial values */
    morpheus_dcopy(ncols, x, y);
    for (int i = 1; i < nrows; ++i) {
      const double *row = x + i*ncols;
      for (int j = 0; j < ncols; ++j) {
        y[j] = pred(y[j], row[j]);
      }
    }
  } else if (layout == morpheus_col_major) {
    for (int j = 0; j < ncols; ++j) {
      const double *column = &x[j*nrows];
      y[j] = column[0];
      for (int i = 1; i < nrows; ++i) {
        y[j] = pred(y[j], column[i]);
      }
    }
  } else {
    perror("unkwnown matrix layout");
    assert(0);
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movq %r8, 0x38(%rsp)
movq %r9, 0x30(%rsp)
cmpl $0x15, 0x4c(%rsp)
jne 0x2aea
movl 0x44(%rsp), %edi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x3b50
movl $0x1, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x48(%rsp), %eax
jge 0x2ae5
movq 0x38(%rsp), %rax
movl 0x2c(%rsp), %ecx
imull 0x44(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x2ad3
movq 0x50(%rsp), %rax
movq 0x30(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x20(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm1
callq *%rax
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2a88
jmp 0x2ad5
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2a55
jmp 0x2bd4
cmpl $0x16, 0x4c(%rsp)
jne 0x2ba7
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x2ba5
movq 0x38(%rsp), %rax
movl 0x18(%rsp), %ecx
imull 0x48(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
movq 0x30(%rsp), %rax
movslq 0x18(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x48(%rsp), %eax
jge 0x2b93
movq 0x50(%rsp), %rax
movq 0x30(%rsp), %rcx
movslq 0x18(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm1
callq *%rax
movq 0x30(%rsp), %rax
movslq 0x18(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2b48
jmp 0x2b95
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2afd
jmp 0x2bd2
leaq 0x26fa(%rip), %rdi      # 0x52a8
callq 0x1110
leaq 0x2705(%rip), %rdi      # 0x52bf
leaq 0x2700(%rip), %rsi      # 0x52c1
movl $0x20, %edx
leaq 0x2708(%rip), %rcx      # 0x52d5
callq 0x1070
jmp 0x2bd4
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/matrix_reduce.c
// Function: morpheus_row_predicate
void morpheus_row_predicate(double (*pred)(double, double),
                            morpheus_layout_e layout,
                            int nrows, int ncols,
                            const double *x,
                            double *y) {
  if (layout == morpheus_row_major) {
    for (int i = 0; i < nrows; ++i) {
      const double *row = x + i*ncols;
      y[i] = row[0];
      for (int j = 1; j < ncols; ++j) {
        y[i] = pred(y[i], row[j]);
      }
    }
  } else if (layout == morpheus_col_major) {
    /* first column is initial values */
    morpheus_dcopy(nrows, x, y);
    for (int j = 1; j < ncols; ++j) {
      const double *column = x + j*nrows;
      for (int i = 0; i < nrows; ++i) {
        y[i] = pred(y[i], column[i]);
      }
    }
  } else {
    perror("unkwnown matrix layout");
    assert(0);
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movq %r8, 0x38(%rsp)
movq %r9, 0x30(%rsp)
cmpl $0x15, 0x4c(%rsp)
jne 0x2cbf
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x48(%rsp), %eax
jge 0x2cba
movq 0x38(%rsp), %rax
movl 0x2c(%rsp), %ecx
imull 0x44(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x1, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x2ca8
movq 0x50(%rsp), %rax
movq 0x30(%rsp), %rcx
movslq 0x2c(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x20(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm1
callq *%rax
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2c5d
jmp 0x2caa
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2c12
jmp 0x2da4
cmpl $0x16, 0x4c(%rsp)
jne 0x2d77
movl 0x48(%rsp), %edi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x3b50
movl $0x1, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x2d75
movq 0x38(%rsp), %rax
movl 0x18(%rsp), %ecx
imull 0x48(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x48(%rsp), %eax
jge 0x2d63
movq 0x50(%rsp), %rax
movq 0x30(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm1
callq *%rax
movq 0x30(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2d18
jmp 0x2d65
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2ce5
jmp 0x2da2
leaq 0x252a(%rip), %rdi      # 0x52a8
callq 0x1110
leaq 0x2535(%rip), %rdi      # 0x52bf
leaq 0x2530(%rip), %rsi      # 0x52c1
movl $0x3c, %edx
leaq 0x25aa(%rip), %rcx      # 0x5347
callq 0x1070
jmp 0x2da4
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/matrix_reduce.c
// Function: morpheus_column_sum
void morpheus_column_sum(morpheus_layout_e layout,
                         int nrows, int ncols,
                         const double *x,
                         double *y) {
  if (layout == morpheus_row_major) {
    for (int j = 0; j < ncols; ++j) {
      y[j] = 0;
    }
    for (int i = 0; i < nrows; ++i) {
      const double *row = x + i*ncols;
      for (int j = 0; j < ncols; ++j) {
        y[j] += row[j];
      }
    }
  } else if (layout == morpheus_col_major) {
    for (int j = 0; j < ncols; ++j) {
      const double *column = &x[j*nrows];
      y[j] = 0;
      for (int i = 0; i < nrows; ++i) {
        y[j] += column[i];
      }
    }
  } else {
    perror("unkwnown matrix layout");
    assert(0);
  }
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
cmpl $0x15, 0x44(%rsp)
jne 0x37eb
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x3766
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x373d
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x40(%rsp), %eax
jge 0x37e6
movq 0x30(%rsp), %rax
movl 0x20(%rsp), %ecx
imull 0x3c(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x37d7
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x379d
jmp 0x37d9
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x376e
jmp 0x38be
cmpl $0x16, 0x44(%rsp)
jne 0x3891
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x388f
movq 0x30(%rsp), %rax
movl 0x10(%rsp), %ecx
imull 0x40(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x40(%rsp), %eax
jge 0x387d
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3843
jmp 0x387f
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x37fe
jmp 0x38bc
leaq 0x1a10(%rip), %rdi      # 0x52a8
callq 0x1110
leaq 0x1a1b(%rip), %rdi      # 0x52bf
leaq 0x1a16(%rip), %rsi      # 0x52c1
movl $0xed, %edx
leaq 0x1c6d(%rip), %rcx      # 0x5524
callq 0x1070
jmp 0x38be
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/matrix_reduce.c
// Function: morpheus_row_sum
void morpheus_row_sum(morpheus_layout_e layout,
                      int nrows, int ncols,
                      const double *x,
                      double *y) {
  if (layout == morpheus_row_major) {
    for (int i = 0; i < nrows; ++i) {
      const double *row = x + i*ncols;
      y[i] = 0;
      for (int j = 0; j < ncols; ++j) {
        y[i] += row[j];
      }
    }
  } else if (layout == morpheus_col_major) {
    for (int i = 0; i < nrows; ++i) {
      y[i] = 0;
    }
    for (int j = 0; j < ncols; ++j) {
      const double *column = x + j*nrows;
      for (int i = 0; i < nrows; ++i) {
        y[i] += column[i];
      }
    }
  } else {
    perror("unkwnown matrix layout");
    assert(0);
  }
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movl %esi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
cmpl $0x15, 0x54(%rsp)
jne 0x3993
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x50(%rsp), %eax
jge 0x398e
movq 0x40(%rsp), %rax
movl 0x34(%rsp), %ecx
imull 0x4c(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x397c
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3942
jmp 0x397e
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x38fd
jmp 0x3a7e
cmpl $0x16, 0x54(%rsp)
jne 0x3a51
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x50(%rsp), %eax
jge 0x39cf
movq 0x38(%rsp), %rax
movslq 0x20(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x39a6
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x3a4f
movq 0x40(%rsp), %rax
movl 0x1c(%rsp), %ecx
imull 0x50(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x50(%rsp), %eax
jge 0x3a40
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x38(%rsp), %rax
movslq 0xc(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3a06
jmp 0x3a42
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x39d7
jmp 0x3a7c
leaq 0x1850(%rip), %rdi      # 0x52a8
callq 0x1110
leaq 0x185b(%rip), %rdi      # 0x52bf
leaq 0x1856(%rip), %rsi      # 0x52c1
movl $0x109, %edx            # imm = 0x109
leaq 0x1afd(%rip), %rcx      # 0x5574
callq 0x1070
jmp 0x3a7e
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/simple_blas.c
// Function: to_cblas_transpose
int to_cblas_transpose(const morpheus_transpose_e trans) {
  switch (trans) {
  case morpheus_no_trans:
    return CblasNoTrans;
  case morpheus_trans:
    return CblasTrans;
  }
  return 0;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
subl $0xb, %eax
je 0x3aae
jmp 0x3aa3
movl -0xc(%rsp), %eax
subl $0xc, %eax
je 0x3ab8
jmp 0x3ac2
movl $0x6f, -0x4(%rsp)
jmp 0x3aca
movl $0x70, -0x4(%rsp)
jmp 0x3aca
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/simple_blas.c
// Function: to_cblas_layout
int to_cblas_layout(const morpheus_layout_e layout) {
  switch (layout) {
  case morpheus_row_major:
    return CblasRowMajor;
  case morpheus_col_major:
    return CblasColMajor;
  }
  return 0;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
subl $0x15, %eax
je 0x3aee
jmp 0x3ae3
movl -0xc(%rsp), %eax
subl $0x16, %eax
je 0x3af8
jmp 0x3b02
movl $0x65, -0x4(%rsp)
jmp 0x3b0a
movl $0x66, -0x4(%rsp)
jmp 0x3b0a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/simple_blas.c
// Function: morpheus_dgemv
void morpheus_dgemv(const morpheus_layout_e layout,
                    const morpheus_transpose_e trans,
                    const int nrows, const int ncols,
                    const double alpha, const double *A, const double *x,
                    const double beta, double *y) {
  const int inc = 1;
  const int lda = layout == morpheus_row_major ? ncols : nrows;
  cblas_dgemv(to_cblas_layout(layout), to_cblas_transpose(trans), nrows, ncols,
              alpha, A, lda, x, inc, beta, y, inc);
}

// Assembly:
subq $0x68, %rsp
movq 0x70(%rsp), %rax
movl %edi, 0x64(%rsp)
movl %esi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movl %ecx, 0x58(%rsp)
movsd %xmm0, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x40(%rsp)
movsd %xmm1, 0x38(%rsp)
movl $0x1, 0x34(%rsp)
cmpl $0x15, 0x64(%rsp)
jne 0x3c18
movl 0x58(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0x3c20
movl 0x5c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x64(%rsp), %edi
callq 0x3ad0
movl %eax, 0x28(%rsp)
movl 0x60(%rsp), %edi
callq 0x3a90
movl 0x28(%rsp), %edi
movl %eax, %esi
movl 0x5c(%rsp), %edx
movl 0x58(%rsp), %ecx
movsd 0x50(%rsp), %xmm0
movq 0x48(%rsp), %r8
movl 0x30(%rsp), %r9d
movq 0x40(%rsp), %r10
movsd 0x38(%rsp), %xmm1
movq 0x70(%rsp), %rax
movq %r10, (%rsp)
movl $0x1, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0x10b0
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/simple_blas.c
// Function: morpheus_inverse
int morpheus_inverse(int n, double *x, int *pivot, double *workspace) {
  workspace = workspace+n;
  int lwork = n*n;

  int rc;
  dgetrf_(&n, &n, x, &n, pivot, &rc);
  if (rc != 0) {
    return rc;
  }
  dgetri_(&n, x, &n, pivot, workspace, &lwork, &rc);
  return rc;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rax
movslq 0x30(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0x30(%rsp), %eax
imull 0x30(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %r8
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r9
movq %rcx, %rdi
movq %rcx, %rsi
callq 0x10c0
cmpl $0x0, 0x10(%rsp)
je 0x3dba
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x3dec
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
leaq 0x30(%rsp), %rdx
leaq 0x14(%rsp), %r9
leaq 0x10(%rsp), %rax
movq %rdx, %rdi
movq %rax, (%rsp)
callq 0x1150
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/simple_blas.c
// Function: morpheus_dger
void morpheus_dger(const morpheus_layout_e layout,
                   const int nrows,
                   const int ncols,
                   const double alpha,
                   const double *x,
                   const double *y,
                   double *a) {
  const int inc = 1;
  const int lda = layout == morpheus_row_major ? ncols : nrows;
  cblas_dger(to_cblas_layout(layout), nrows, ncols,
                             alpha, x, inc, y, inc, a, lda);
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movl %esi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movsd %xmm0, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movl $0x1, 0x24(%rsp)
cmpl $0x15, 0x54(%rsp)
jne 0x3e3e
movl 0x4c(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x3e46
movl 0x50(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x54(%rsp), %edi
callq 0x3ad0
movl %eax, %edi
movl 0x50(%rsp), %esi
movl 0x4c(%rsp), %edx
movsd 0x40(%rsp), %xmm0
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %r10
movl 0x20(%rsp), %eax
movl $0x1, %r8d
movl $0x1, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x10a0
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/simple_blas.c
// Function: morpheus_dgemm
void morpheus_dgemm(const morpheus_layout_e layout,
                    const morpheus_transpose_e trans_a,
                    const morpheus_transpose_e trans_b,
                    const int m,
                    const int n,
                    const int k,
                    const double alpha,
                    const double *a,
                    const double *b,
                    const double beta,
                    double *c) {
  int lda, ldb, ldc;
  if (layout == morpheus_row_major) {
    lda = trans_a == morpheus_no_trans ? k : m;
    ldb = trans_b == morpheus_no_trans ? n : k;
    ldc = n;
  } else {
    lda = trans_a == morpheus_no_trans ? m : k;
    ldb = trans_b == morpheus_no_trans ? k : n;
    ldc = m;
  }
  cblas_dgemm(to_cblas_layout(layout),
              to_cblas_transpose(trans_a), to_cblas_transpose(trans_b),
              m, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq 0xb0(%rsp), %rax
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rax
movl %edi, 0x7c(%rsp)
movl %esi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movl %ecx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movl %r9d, 0x68(%rsp)
movsd %xmm0, 0x60(%rsp)
movsd %xmm1, 0x58(%rsp)
cmpl $0x15, 0x7c(%rsp)
jne 0x3f3c
cmpl $0xb, 0x78(%rsp)
jne 0x3f01
movl 0x68(%rsp), %eax
movl %eax, 0x48(%rsp)
jmp 0x3f09
movl 0x70(%rsp), %eax
movl %eax, 0x48(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x54(%rsp)
cmpl $0xb, 0x74(%rsp)
jne 0x3f22
movl 0x6c(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x3f2a
movl 0x68(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x50(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x4c(%rsp)
jmp 0x3f86
cmpl $0xb, 0x78(%rsp)
jne 0x3f4d
movl 0x70(%rsp), %eax
movl %eax, 0x40(%rsp)
jmp 0x3f55
movl 0x68(%rsp), %eax
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x54(%rsp)
cmpl $0xb, 0x74(%rsp)
jne 0x3f6e
movl 0x68(%rsp), %eax
movl %eax, 0x3c(%rsp)
jmp 0x3f76
movl 0x6c(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x50(%rsp)
movl 0x70(%rsp), %eax
movl %eax, 0x4c(%rsp)
movl 0x7c(%rsp), %edi
callq 0x3ad0
movl %eax, 0x34(%rsp)
movl 0x78(%rsp), %edi
callq 0x3a90
movl %eax, 0x38(%rsp)
movl 0x74(%rsp), %edi
callq 0x3a90
movl 0x34(%rsp), %edi
movl 0x38(%rsp), %esi
movl %eax, %edx
movl 0x70(%rsp), %ecx
movl 0x6c(%rsp), %r8d
movl 0x68(%rsp), %r9d
movsd 0x60(%rsp), %xmm0
movq 0xa0(%rsp), %r14
movl 0x54(%rsp), %ebp
movq 0xa8(%rsp), %rbx
movl 0x50(%rsp), %r11d
movsd 0x58(%rsp), %xmm1
movq 0xb0(%rsp), %r10
movl 0x4c(%rsp), %eax
movq %r14, (%rsp)
movl %ebp, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x1130
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligusnet[P]morpheus/src/simple_blas.c
// Function: morpheus_identity
void morpheus_identity(const int n, double *a) {
  const int m = n*n;
  const double zero = 0;
  const double one = 1;
  cblas_dcopy(m, &zero, 0, a, 1);
  cblas_dcopy(n, &one, 0, a, n+1);
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x24(%rsp), %eax
imull 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x1255(%rip), %xmm0     # 0x52a0
movsd %xmm0, (%rsp)
movl 0x14(%rsp), %edi
movq 0x18(%rsp), %rcx
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
movl $0x1, %r8d
callq 0x10d0
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %r8d
addl $0x1, %r8d
movq %rsp, %rsi
xorl %edx, %edx
callq 0x10d0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-mbim-proxy.c
// Function: mbim_send_open_msg
static int mbim_send_open_msg(int mbim_dev_fd, uint32_t MaxControlTransfer) {
    MBIM_OPEN_MSG_T open_msg;
    MBIM_OPEN_MSG_T *pRequest = &open_msg;

    pRequest->MessageHeader.MessageType = htole32(MBIM_OPEN_MSG);
    pRequest->MessageHeader.MessageLength = htole32(sizeof(MBIM_OPEN_MSG_T));
    pRequest->MessageHeader.TransactionId = htole32(1);
    pRequest->MaxControlTransfer = htole32(MaxControlTransfer);

    mbim_debug("%s()\n", __func__);
    return non_block_write(mbim_dev_fd, pRequest, sizeof(MBIM_OPEN_MSG_T));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, %edi
callq 0x1c60
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x10, %edi
callq 0x1c60
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x1, %edi
callq 0x1c60
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x8(%rbp), %edi
callq 0x1c60
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq 0x38fa(%rip), %rax      # 0x4fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x12a0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x1a21(%rip), %rsi      # 0x3111
leaq 0x1a23(%rip), %rcx      # 0x311a
movb $0x0, %al
callq 0x10f0
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x1c70
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-mbim-proxy.c
// Function: non_block_write
static int non_block_write(int fd, void *data, int len)
{
    int ret;
    struct pollfd pollfd = {fd, POLLOUT, 0};
    ret = poll(&pollfd, 1, 3000);

    if (ret <= 0) {
        mbim_debug("%s poll ret=%d, errno: %d(%s)\n", __func__, ret, errno, strerror(errno));
    }

    ret = write (fd, data, len);
    if (ret != len)
        mbim_debug("%s write ret=%d, errno: %d(%s)\n", __func__, ret, errno, strerror(errno));

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movw $0x4, -0x1c(%rbp)
movw $0x0, -0x1a(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
movl $0xbb8, %edx            # imm = 0xBB8
callq 0x1120
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x1d10
jmp 0x1cb2
movq 0x3317(%rip), %rax      # 0x4fd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x12a0
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
callq 0x1040
movl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1170
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl -0x28(%rbp), %r8d
movl -0x24(%rbp), %r9d
leaq 0x1431(%rip), %rsi      # 0x312d
leaq 0x144c(%rip), %rcx      # 0x314f
movq %rax, (%rsp)
movb $0x0, %al
callq 0x10f0
jmp 0x1d10
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x1070
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1d8b
jmp 0x1d2d
movq 0x329c(%rip), %rax      # 0x4fd0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
callq 0x12a0
movq %rax, -0x48(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0x1040
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1170
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movl -0x40(%rbp), %r8d
movl -0x3c(%rbp), %r9d
leaq 0x13e8(%rip), %rsi      # 0x315f
leaq 0x13d1(%rip), %rcx      # 0x314f
movq %rax, (%rsp)
movb $0x0, %al
callq 0x10f0
jmp 0x1d8b
movl -0x14(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/quectel-mbim-proxy.c
// Function: handle_client_disconnect
static void handle_client_disconnect(int client_fd)
{
    int i;

    for (i = 0; i < CM_MAX_CLIENT; i++) {
        if (cm_clients[i].client_fd == client_fd) {
            mbim_debug("%s client_fd=%d, client_idx=%d\n", __func__, cm_clients[i].client_fd, cm_clients[i].client_idx);
            safe_close(cm_clients[i].client_fd);
            return;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x20, -0x8(%rbp)
jge 0x1e6f
movslq -0x8(%rbp), %rcx
leaq 0x33b9(%rip), %rax      # 0x5180
movl (%rax,%rcx,8), %eax
cmpl -0x4(%rbp), %eax
jne 0x1e5f
jmp 0x1dd5
movq 0x31f4(%rip), %rax      # 0x4fd0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x12a0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
movslq -0x8(%rbp), %rcx
leaq 0x3386(%rip), %rax      # 0x5180
movl (%rax,%rcx,8), %r8d
movslq -0x8(%rbp), %rcx
leaq 0x3377(%rip), %rax      # 0x5180
movl 0x4(%rax,%rcx,8), %r9d
leaq 0x1420(%rip), %rsi      # 0x3235
leaq 0x143c(%rip), %rcx      # 0x3258
movb $0x0, %al
callq 0x10f0
jmp 0x1e25
movslq -0x8(%rbp), %rcx
leaq 0x3350(%rip), %rax      # 0x5180
cmpl $0x0, (%rax,%rcx,8)
jle 0x1e5b
movslq -0x8(%rbp), %rcx
leaq 0x333f(%rip), %rax      # 0x5180
movl (%rax,%rcx,8), %edi
callq 0x10d0
movslq -0x8(%rbp), %rcx
leaq 0x332c(%rip), %rax      # 0x5180
movl $0xffffffff, (%rax,%rcx,8) # imm = 0xFFFFFFFF
jmp 0x1e5d
jmp 0x1e6f
jmp 0x1e61
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1db2
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-unssa.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list * filelist = NULL;
	char *file;

	compile(sparse_initialize(argc, argv, &filelist));
	FOR_EACH_PTR(filelist, file) {
		compile(sparse(file));
	} END_FOR_EACH_PTR(file);

	report_stats();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x1ae50
movq %rax, %rdi
callq 0x11550
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x114b7
jmp 0x11534
jmp 0x114b9
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x11520
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x11504
cmpq $0x0, -0x20(%rbp)
jne 0x11504
jmp 0x11515
movq -0x20(%rbp), %rdi
callq 0x1b2c0
movq %rax, %rdi
callq 0x11550
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x114c0
jmp 0x11522
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x114b9
callq 0x43250
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-unssa.c
// Function: compile
static int compile(struct symbol_list *list)
{
	struct symbol *sym;
	FOR_EACH_PTR(list, sym) {
		struct entrypoint *ep;
		expand_symbol(sym);
		ep = linearize_symbol(sym);
		if (!(fdump_ir & PASS_FINAL))
			continue;
		if (ep)
			output_fn(ep);
		else
			output_data(sym);
	}
	END_FOR_EACH_PTR(sym);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11580
jmp 0x11640
jmp 0x11582
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x11628
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x115d1
cmpq $0x0, -0x10(%rbp)
jne 0x115d1
jmp 0x1161a
movq -0x10(%rbp), %rdi
callq 0x11db0
movq -0x10(%rbp), %rdi
callq 0x1e5c0
movq %rax, -0x38(%rbp)
leaq 0x7cd1a(%rip), %rax     # 0x8e308
movq (%rax), %rax
andq $0x10, %rax
cmpq $0x0, %rax
jne 0x115fd
jmp 0x1161a
cmpq $0x0, -0x38(%rbp)
je 0x1160f
movq -0x38(%rbp), %rdi
callq 0x11650
jmp 0x11618
movq -0x10(%rbp), %rdi
callq 0x117a0
jmp 0x1161a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11589
jmp 0x1162a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x11582
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-unssa.c
// Function: output_fn
static void output_fn(struct entrypoint *ep)
{
	struct basic_block *bb;
	unsigned long generation = ++bb_generation;
	struct symbol *sym = ep->name;
	const char *name = show_ident(sym->ident);

	if (sym->ctype.modifiers & MOD_STATIC)
		printf("\n\n%s:\n", name);
	else
		printf("\n\n.globl %s\n%s:\n", name, name);

	unssa(ep);

	FOR_EACH_PTR(ep->bbs, bb) {
		if (bb->generation == generation)
			continue;
		output_bb(bb, generation);
	}
	END_FOR_EACH_PTR(bb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7b25d(%rip), %rax     # 0x8c8c0
movq (%rax), %rax
addq $0x1, %rax
leaq 0x7b24f(%rip), %rcx     # 0x8c8c0
movq %rax, (%rcx)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x48000
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0x116ba
movq -0x28(%rbp), %rsi
leaq 0x50953(%rip), %rdi     # 0x62004
movb $0x0, %al
callq 0x110f0
jmp 0x116d0
movq -0x28(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0x50942(%rip), %rdi     # 0x6200b
movb $0x0, %al
callq 0x110f0
movq -0x8(%rbp), %rdi
callq 0x4a1b0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x11701
jmp 0x1178e
jmp 0x11703
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x11776
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1174e
cmpq $0x0, -0x10(%rbp)
jne 0x1174e
jmp 0x1176b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x1175e
jmp 0x1176b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11810
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1170a
jmp 0x11778
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x11703
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-unssa.c
// Function: output_data
static int output_data(struct symbol *sym)
{
	printf("symbol %s:\n", show_ident(sym->ident));
	printf("\ttype = %d\n", sym->ctype.base_type->type);
	printf("\tmodif= %lx\n", sym->ctype.modifiers);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x48000
movq %rax, %rsi
leaq 0x50859(%rip), %rdi     # 0x6201c
movb $0x0, %al
callq 0x110f0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movl (%rax), %esi
andl $0xff, %esi
leaq 0x50847(%rip), %rdi     # 0x62028
movb $0x0, %al
callq 0x110f0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
leaq 0x5083d(%rip), %rdi     # 0x62034
movb $0x0, %al
callq 0x110f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-unssa.c
// Function: output_bb
static void output_bb(struct basic_block *bb, unsigned long generation)
{
	struct instruction *insn;

	bb->generation = generation;
	printf("%s\n", show_label(bb));

	FOR_EACH_PTR(bb->insns, insn) {
		if (!insn->bb)
			continue;
		printf("\t%s\n", show_instruction(insn));
	}
	END_FOR_EACH_PTR(insn);

	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x1b8f0
movq %rax, %rsi
leaq 0x57039(%rip), %rdi     # 0x68878
movb $0x0, %al
callq 0x110f0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1186e
jmp 0x11905
jmp 0x11870
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x118ed
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x118bb
cmpq $0x0, -0x18(%rbp)
jne 0x118bb
jmp 0x118e2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x118c8
jmp 0x118e2
movq -0x18(%rbp), %rdi
callq 0x1bcf0
movq %rax, %rsi
leaq 0x56f9c(%rip), %rdi     # 0x68877
movb $0x0, %al
callq 0x110f0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x11877
jmp 0x118ef
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x11870
leaq 0x569f7(%rip), %rdi     # 0x68303
movb $0x0, %al
callq 0x110f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/unssa.c
// Function: unssa
int unssa(struct entrypoint *ep)
{
	struct basic_block *bb;

	FOR_EACH_PTR(ep->bbs, bb) {
		rewrite_phi_bb(bb);
	} END_FOR_EACH_PTR(bb);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4a1e1
jmp 0x4a256
jmp 0x4a1e3
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x4a242
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x4a22e
cmpq $0x0, -0x10(%rbp)
jne 0x4a22e
jmp 0x4a237
movq -0x10(%rbp), %rdi
callq 0x4a260
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4a1ea
jmp 0x4a244
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x4a1e3
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop