LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/util.c
// Function: is_nan_str
static int is_nan_str(const char *str) {
  int i;
  char uc_str[4];

  /* convert first three chars to uppercase string */
  i = 0;
  while((str[i] != '\0') && (!isspace(str[i])) && (i < 3)) {
    uc_str[i] = toupper(str[i]);
    i++;
  }
  uc_str[i] = '\0';

  /* is this a NAN? */
  if(i == 3) {
    return (strncmp(uc_str, "NAN", 3) == 0);
  }

  /* is this a NA? */
  return (strncmp(uc_str, "NA", 2) == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x3f7e
callq 0x2170
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x3f7e
cmpl $0x3, -0x14(%rbp)
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3f87
jmp 0x3fad
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2090
movb %al, %cl
movslq -0x14(%rbp), %rax
movb %cl, -0x18(%rbp,%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3f33
movslq -0x14(%rbp), %rax
movb $0x0, -0x18(%rbp,%rax)
cmpl $0x3, -0x14(%rbp)
jne 0x3fe1
leaq -0x18(%rbp), %rdi
leaq 0x133a(%rip), %rsi      # 0x5301
movl $0x3, %edx
callq 0x20f0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x4004
leaq -0x18(%rbp), %rdi
leaq 0x1319(%rip), %rsi      # 0x5305
movl $0x2, %edx
callq 0x20f0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/err.c
// Function: my_err
void my_err(const char *format, ...) {
  int i;

  va_list args;
  va_start(args, format);
  fprintf(stderr, "ERROR: ");
  vfprintf(stderr, format, args);
  
  i = strlen(format);
  if(i < 1 || format[i-1] != '\n') {
    /* add new line */
    fprintf(stderr, "\n");
  }

  va_end(args);
  abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x4048
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x2f46(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
leaq 0x1264(%rip), %rsi      # 0x5308
movb $0x0, %al
callq 0x2270
movq 0x2f2e(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2140
movq -0x8(%rbp), %rdi
callq 0x2150
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0x40ea
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x4102
movq 0x2eef(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
leaq 0x1086(%rip), %rsi      # 0x5181
movb $0x0, %al
callq 0x2270
leaq -0x30(%rbp), %rax
callq 0x2070
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/err.c
// Function: my_warn
void my_warn(const char *format, ...) {
  int i;

  va_list args;
  va_start(args, format);
  fprintf(stderr, "WARNING: ");
  vfprintf(stderr, format, args);
  
  i = strlen(format);
  if(i < 1 || format[i-1] != '\n') {
    /* add new line */
    fprintf(stderr, "\n");
  }

  va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x4148
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x2e46(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
leaq 0x116c(%rip), %rsi      # 0x5310
movb $0x0, %al
callq 0x2270
movq 0x2e2e(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2140
movq -0x8(%rbp), %rdi
callq 0x2150
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0x41ea
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x4202
movq 0x2def(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
leaq 0xf86(%rip), %rsi       # 0x5181
movb $0x0, %al
callq 0x2270
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/memutil.c
// Function: my_malloc
void *my_malloc(size_t n_bytes) {
  void *mem;
 
  mem = malloc(n_bytes);
  if(!mem) {
    my_err("%s:%d: could not allocate %ld bytes of memory\n",
	  __FILE__, __LINE__, n_bytes);
  }

  return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2100
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x425e
movq -0x8(%rbp), %rcx
leaq 0x10cf(%rip), %rdi      # 0x531a
leaq 0x10f7(%rip), %rsi      # 0x5349
movl $0x13, %edx
movb $0x0, %al
callq 0x4010
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/memutil.c
// Function: my_malloc0
void *my_malloc0(size_t n_bytes) {
  void *mem;

  mem = my_malloc(n_bytes);
  memset(mem, 0, n_bytes);
  return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4220
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x2040
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/memutil.c
// Function: _MY_FREE
void __MY_FREE(void *ptr, const char *filename, const int line_num) {
  if(ptr == NULL) {
    my_err("%s:%d: attempt to free NULL ptr at: %s:%d\n",
	  __FILE__, __LINE__, filename, line_num);
  }
  free(ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x42ec
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq 0x107a(%rip), %rdi      # 0x5353
leaq 0x1069(%rip), %rsi      # 0x5349
movl $0x2e, %edx
movb $0x0, %al
callq 0x4010
movq -0x8(%rbp), %rdi
callq 0x22b0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/matrix.c
// Function: main
int main(int arcg, char *argv[]) {
    scg_config_t config = scg_config_new_default();
    config.video.title = "SCG Example: Matrix";

    scg_app_t app;
    scg_app_init(&app, config);

    srand(scg_get_performance_counter());

    int num_columns = app.draw_target->width / CODE_STRING_CHAR_SIZE;
    int num_rows = app.draw_target->height / CODE_STRING_CHAR_SIZE;
    matrix_t matrix;
    matrix_init(&matrix, num_columns, num_rows);

    while (scg_app_process_events(&app)) {
        update(&matrix, &app);

        draw(app.draw_target, &matrix);

        scg_app_present(&app);
    }

    free(matrix.code_strings);
    scg_app_free(&app);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4a00
leaq 0x1e73(%rip), %rax      # 0x859c
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xa0(%rbp), %rdi
callq 0x4a50
callq 0x2680
movl %eax, %edi
callq 0x2260
movq -0x68(%rbp), %rax
movl (%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0xa4(%rbp)
movq -0x68(%rbp), %rax
movl 0x4(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0xa8(%rbp)
movl -0xa4(%rbp), %esi
movl -0xa8(%rbp), %edx
leaq -0xc0(%rbp), %rdi
callq 0x6810
leaq -0xa0(%rbp), %rdi
callq 0x56d0
testb $0x1, %al
jne 0x67b2
jmp 0x67e3
leaq -0xc0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x68b0
movq -0x68(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x69a0
leaq -0xa0(%rbp), %rdi
callq 0x5820
jmp 0x67a0
movq -0xb0(%rbp), %rdi
callq 0x22b0
leaq -0xa0(%rbp), %rdi
callq 0x5cd0
xorl %eax, %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/matrix.c
// Function: matrix_init
static void matrix_init(matrix_t *matrix, int num_columns, int num_rows) {
    int num_code_strings = num_columns * 2;
    code_string_t *code_strings =
        malloc(num_code_strings * sizeof(*code_strings));

    for (int i = 0; i < num_code_strings; i++) {
        init_code_string(&code_strings[i], num_columns);
    }

    matrix->num_columns = num_columns;
    matrix->num_rows = num_rows;
    matrix->num_code_strings = num_code_strings;
    matrix->code_strings = code_strings;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
imulq $0x178, %rax, %rdi      # imm = 0x178
callq 0x2310
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6872
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0x178, %rax, %rax      # imm = 0x178
addq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x6e70
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6845
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/matrix.c
// Function: update
static void update(matrix_t *matrix, scg_app_t *app) {
    int num_code_strings = matrix->num_code_strings;
    int h = app->draw_target->height;
    float32_t delta_time = app->delta_time;

    for (int i = 0; i < num_code_strings; i++) {
        code_string_t *code_string = &matrix->code_strings[i];

        code_string->y += code_string->speed * delta_time;

        int num_chars = code_string->num_chars;
        float32_t code_string_end_y =
            code_string->y - (float32_t)(CODE_STRING_CHAR_SIZE * num_chars);

        if (code_string_end_y >= h) {
            init_code_string(code_string, matrix->num_columns);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x698b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x178, %rcx, %rcx      # imm = 0x178
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movss 0x8(%rax), %xmm0
movss -0x1c(%rbp), %xmm2
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x4(%rax)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm0
movl -0x2c(%rbp), %eax
shll $0x3, %eax
cvtsi2ss %eax, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
cvtsi2ssl -0x18(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jb 0x697b
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x6e70
jmp 0x697d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x68ed
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/matrix.c
// Function: init_code_string
static void init_code_string(code_string_t *code_string, int num_columns) {
    float32_t x = (float32_t)((rand() % num_columns) * CODE_STRING_CHAR_SIZE);
    float32_t y = -10.0f;
    float32_t speed = (float32_t)((rand() % 40) + 5);
    int num_chars = (rand() % (CODE_STRING_MAX_CHARS - 10)) + 10;

    for (int i = 0; i < num_chars; i++) {
        code_string->chars[i] = random_wchar();
    }

    code_string->x = x;
    code_string->y = y;
    code_string->speed = speed;
    code_string->num_chars = num_chars;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x2080
cltd
idivl -0xc(%rbp)
shll $0x3, %edx
cvtsi2ss %edx, %xmm0
movss %xmm0, -0x10(%rbp)
movss 0x117c(%rip), %xmm0     # 0x8018
movss %xmm0, -0x14(%rbp)
callq 0x2080
movl $0x28, %ecx
cltd
idivl %ecx
addl $0x5, %edx
cvtsi2ss %edx, %xmm0
movss %xmm0, -0x18(%rbp)
callq 0x2080
movl $0x50, %ecx
cltd
idivl %ecx
addl $0xa, %edx
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6efa
callq 0x6f40
movl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, 0x10(%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6ed4
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/matrix.c
// Function: random_wchar
static inline wchar_t random_wchar(void) {
    // One in ten chance of being an english ASCII character.
    if ((rand() % 10) == 0) {
        return (wchar_t)(rand() % (126 - 33) + 33);
    }

    // Otherwise return a Hiragana character.
    return (wchar_t)(rand() % (0x3094 - 0x3041) + 0x3041);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x2080
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x6f6f
callq 0x2080
movl $0x5d, %ecx
cltd
idivl %ecx
addl $0x21, %edx
movl %edx, -0x4(%rbp)
jmp 0x6f85
callq 0x2080
movl $0x53, %ecx
cltd
idivl %ecx
addl $0x3041, %edx           # imm = 0x3041
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/matrix.c
// Function: shade_pixel
static inline scg_pixel_t shade_pixel(scg_pixel_t color, float32_t shade) {
    uint8_t r = (uint8_t)((float32_t)color.data.r * shade);
    uint8_t g = (uint8_t)((float32_t)color.data.g * shade);
    uint8_t b = (uint8_t)((float32_t)color.data.b * shade);

    return scg_pixel_new_rgb(r, g, b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movzbl -0x6(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss -0xc(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, -0xd(%rbp)
movzbl -0x7(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss -0xc(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, -0xe(%rbp)
movzbl -0x8(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss -0xc(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, -0xf(%rbp)
movb -0xf(%rbp), %al
movb %al, -0x4(%rbp)
movb -0xe(%rbp), %al
movb %al, -0x3(%rbp)
movb -0xd(%rbp), %al
movb %al, -0x2(%rbp)
movb $-0x1, -0x1(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-lexing.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;

	preprocess_only = 1;
	sparse_initialize(argc, argv, &filelist);
	FOR_EACH_PTR(filelist, file) {
		sparse(file);
	} END_FOR_EACH_PTR(file);
	show_identifier_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)
leaq 0x799f7(%rip), %rax     # 0x8ae4c
movl $0x1, (%rax)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x11c90
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 0x1148c
jmp 0x11501
jmp 0x1148e
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 0x114ed
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 0x114d9
cmpq $0x0, -0x20(%rbp)
jne 0x114d9
jmp 0x114e2
movq -0x20(%rbp), %rdi
callq 0x12100
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x11495
jmp 0x114ef
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x1148e
callq 0x2c120
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/usgs[P]nshmp-haz-catalogs/src/agrid/adaptive/read_write_params.c
// Function: read_params_new_old
int read_params_new_old(char *parf, struct compl_levels* cat_comp, struct boundaries* reg, 
  struct catalog* cat, struct smoothp* smp, char *outfnm, int new_style_formatting) 
/*--------------------------------------------------------------------------*/
{
  int retVal=0;

// read parameters
  if ( new_style_formatting ) {
//    retVal=read_params_new(parf, &cat_compl, &region, &cat, &smoothing_params, outf);
    retVal=read_params_new(parf, cat_comp, reg, cat, smp, outfnm);
    if ( (cat_comp->variableCompleteness) == 1 ) read_completenessVals(cat_comp);
    if ( ! retVal ) fprintf(stderr, "\nError reading parameter file, %s with newer-style formatting\n", outfnm); 
  }
  else {
//    retVal=read_params(parf, &cat_comp, &reg, &cat, &smp, outfnm);
    retVal=read_params(parf, cat_comp, reg, cat, smp, outfnm);
    if ( ! retVal ) fprintf(stderr, "\nError reading parameter file, %s with older-style formatting\n", outfnm); 
    fprintf(stderr,"Old-style formatting for parameter input is deprecated and is no longer supported. The option remains in the code for legacy comparisons but requires to user to modify the code to remove the exit statment in the read_write_params.c function.\n");
    exit(1);
  }
  cat_comp->end_yr=cat->end_yr;
  cat_comp->dMag=cat->dMag;

  return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x0, 0x10(%rbp)
je 0x17a6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x1840
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x1782
movq -0x10(%rbp), %rdi
callq 0x1e40
cmpl $0x0, -0x34(%rbp)
jne 0x17a4
movq 0xa869(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
leaq 0x6c12(%rip), %rsi      # 0x83af
movb $0x0, %al
callq 0x10e0
jmp 0x180a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x1f70
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x17e8
movq 0xa825(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
leaq 0x6c0d(%rip), %rsi      # 0x83ee
movb $0x0, %al
callq 0x10e0
movq 0xa809(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x6c34(%rip), %rsi      # 0x842d
movb $0x0, %al
callq 0x10e0
movl $0x1, %edi
callq 0x1160
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x64(%rax)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/usgs[P]nshmp-haz-catalogs/src/agrid/adaptive/read_write_params.c
// Function: read_completenessVals
void read_completenessVals(struct compl_levels* cat_comp)
/*--------------------------------------------------------------------------*/
{
  FILE *fp;
  int cnt=0;
  char buff[BUFFLEN];

  if( (fp = fopen(cat_comp->completenessFile, "r"))==NULL) {
    fprintf(stderr,"File with variable completeness values (lon-lat-year) not found, %s\n", cat_comp->completenessFile);
    exit(1);
  }
  while( fgets(buff,BUFFLEN,fp) ) {
    sscanf(buff, "%f %f %d", &(cat_comp->lon_arr[cnt]), &(cat_comp->lat_arr[cnt]), &(cat_comp->yrCompl_arr[cnt]) );
    cnt++;
  }
  fclose(fp);

//
  cat_comp->nVarComp=cnt;
  fprintf(stderr,"Read variable completeness values from file, %s, with %d points\n", cat_comp->completenessFile, cat_comp->nVarComp);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x6a52(%rip), %rsi      # 0x88b7
callq 0x1130
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1e9e
movq 0xa17d(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
addq $0x68, %rdx
leaq 0x6693(%rip), %rsi      # 0x8520
movb $0x0, %al
callq 0x10e0
movl $0x1, %edi
callq 0x1160
jmp 0x1ea0
leaq -0x140(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x12c, %esi            # imm = 0x12C
callq 0x10c0
cmpq $0x0, %rax
je 0x1f1d
leaq -0x140(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0x14c344, %rdx         # imm = 0x14C344
movslq -0x14(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rcx
addq $0x1f2384, %rcx         # imm = 0x1F2384
movslq -0x14(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rcx
movq -0x8(%rbp), %r8
addq $0x2c4, %r8             # imm = 0x2C4
movslq -0x14(%rbp), %rax
shlq $0x2, %rax
addq %rax, %r8
leaq 0x665a(%rip), %rsi      # 0x8565
movb $0x0, %al
callq 0x1100
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1ea0
movq -0x10(%rbp), %rdi
callq 0x1080
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c0(%rax)
movq 0xa0be(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
addq $0x68, %rdx
movq -0x8(%rbp), %rax
movl 0x2c0(%rax), %ecx
leaq 0x6618(%rip), %rsi      # 0x856e
movb $0x0, %al
callq 0x10e0
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/usgs[P]nshmp-haz-catalogs/src/agrid/adaptive/init_dist_rates.c
// Function: init_dist_rates
void init_dist_rates(struct eqcat* catn, float atot[], struct rates* seisr)
/*--------------------------------------------------------------------------*/
{
  int cnt, cnt1;
//  float initv=1e-12;

// initialize rates and distances to zero
  for(cnt=0; cnt<(int)NV; cnt++) {
    atot[cnt]=0.0;
    seisr->asum_cnt_int[cnt]=0;
    seisr->asum_cnt[cnt]=0.0;
    seisr->asum[cnt]=0.0;
/*    seisr->asum3[cnt]=0.0;
    seisr->asum3p5[cnt]=0.0;
    seisr->asum4[cnt]=0.0;
    seisr->asum4p5[cnt]=0.0;
    seisr->asum5[cnt]=0.0;
*/
    seisr->asum_noSm[cnt]=0.0;
  }
// initialize neighbor numbers to zero
  for(cnt=0; cnt<(int)NEQ; cnt++) {
    for(cnt1=0; cnt1<(int)NNUM; cnt1++) {
      catn->dist_nbr[cnt][cnt1]=0.0;
    }
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x29810, -0x1c(%rbp)   # imm = 0x29810
jge 0x2cc6
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, 0xa6040(%rax,%rcx,4)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, 0x14c080(%rax,%rcx,4)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, 0x1f20c0(%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2c57
movl $0x0, -0x1c(%rbp)
cmpl $0x3a98, -0x1c(%rbp)    # imm = 0x3A98
jge 0x2d1c
movl $0x0, -0x20(%rbp)
cmpl $0xa, -0x20(%rbp)
jge 0x2d0f
movq -0x8(%rbp), %rax
addq $0xbe6e4, %rax          # imm = 0xBE6E4
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2cdd
jmp 0x2d11
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2ccd
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/usgs[P]nshmp-haz-catalogs/src/agrid/adaptive/smooth_seis_rates.c
// Function: get_sigma_value
float get_sigma_value(struct smoothp* smp, struct eqcat* catn, int eqno)
/*--------------------------------------------------------------------------*/
{
  int neighbor_num=-999, neighbor_num_2=-999;
  float sigma;

// fixed-radius smoothing
  if (smp->adapt_sm == 0 ) {
    sigma=smp->sigfix;
  }
// adaptive-radius smoothing
  else {
// shift for c array indexing
    neighbor_num=smp->nnum-1;
    if ( smp->nnum2_log == 0 ) {
      sigma=catn->dist_nbr[eqno][neighbor_num];
    }
    else {
      neighbor_num_2=smp->nnum2-1;
      sigma=(catn->dist_nbr[eqno][neighbor_num]+catn->dist_nbr[eqno][neighbor_num_2])/2;
    }
    if (sigma < smp->sigmin) sigma=smp->sigmin;
  }
  
  return sigma;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0xfffffc19, -0x18(%rbp) # imm = 0xFFFFFC19
movl $0xfffffc19, -0x1c(%rbp) # imm = 0xFFFFFC19
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x463a
movq -0x8(%rbp), %rax
movss 0x2c(%rax), %xmm0
movss %xmm0, -0x20(%rbp)
jmp 0x46f3
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x4676
movq -0x10(%rbp), %rax
addq $0xbe6e4, %rax          # imm = 0xBE6E4
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x20(%rbp)
jmp 0x46d0
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0xbe6e4, %rax          # imm = 0xBE6E4
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
addq $0xbe6e4, %rax          # imm = 0xBE6E4
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss 0x4649(%rip), %xmm1     # 0x8d10
divss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss 0x24(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x46f1
movq -0x8(%rbp), %rax
movss 0x24(%rax), %xmm0
movss %xmm0, -0x20(%rbp)
jmp 0x46f3
movss -0x20(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/usgs[P]nshmp-haz-catalogs/src/agrid/adaptive/write_asum_to_file.c
// Function: write_unsmoothed_asum_to_file
void write_unsmoothed_asum_to_file(struct rates* seisr, char *fbasenm)
/*--------------------------------------------------------------------------*/
{ 
  FILE *fpout;
//  int nsrc, cnt, ierr;
  int nsrc, cnt, ierr;
  float asum[NV];
  char fileout[200];
//  struct header headr;


// get rate array and naming based on magnitude input values
  nsrc=seisr->nv;
// no-smoothing
  sprintf(fileout,"%s_noSmooth.out", fbasenm);
  for(cnt=0; cnt<nsrc; cnt++) asum[cnt]=seisr->asum_noSm[cnt];

// write results to file, fileout
  fpout=fopen(fileout,"wb+");
  ierr=fwrite(asum,4,nsrc,fpout);
  fclose(fpout);
  fprintf(stderr,"Wrote un-smoothed results to file, %s.\n", fileout);
  

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa6140, %rsp          # imm = 0xA6140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x298100(%rax), %eax
movl %eax, -0x1c(%rbp)
leaq -0xa6140(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3058(%rip), %rsi      # 0x960a
movb $0x0, %al
callq 0x1150
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x65f1
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss 0x1f20c0(%rax,%rcx,4), %xmm0
movslq -0x20(%rbp), %rax
movss %xmm0, -0xa6070(%rbp,%rax,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x65c0
leaq -0xa6140(%rbp), %rdi
leaq 0x2fa1(%rip), %rsi      # 0x95a0
callq 0x1130
movq %rax, -0x18(%rbp)
leaq -0xa6070(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x4, %esi
callq 0x1170
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1080
movq 0x59c4(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq -0xa6140(%rbp), %rdx
leaq 0x2fd5(%rip), %rsi      # 0x961a
movb $0x0, %al
callq 0x10e0
addq $0xa6140, %rsp          # imm = 0xA6140
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/usgs[P]nshmp-haz-catalogs/src/agrid/adaptive/initialize_params.c
// Function: initialize_params
void initialize_params(struct compl_levels* cat_comp, struct boundaries* reg, 
  struct catalog* cat, struct smoothp* smp)
/*--------------------------------------------------------------------------*/
{
// boundaries structure
  reg->minlat=-9999.0;
  reg->maxlat=-9999.0;
  reg->minlon=-9999.0;
  reg->maxlon=-9999.0;
  reg->dlon=-9999.0;
  reg->dlat=-9999.0;
  reg->nsx=0;
  reg->nsy=0;
  reg->nsrc=0;

// compl_levels structure
  cat_comp->nlevels=0;
  cat_comp->end_yr=0;
  cat_comp->dMag=0.0;
  cat_comp->variableCompleteness=0;
  cat_comp->catalogGaps=0;
  cat_comp->nVarComp=0;

// catalog structure
  cat->end_yr=0;
  cat->minMag=0;
  cat->dMag=0.0;
  cat->bval=-9999.0;

// smoothp structure
  smp->cumul_rates=1;
  smp->adj_compl=0;
  smp->apply_sm=0;
  smp->adapt_sm=0;
  smp->nnum2_log=0;
  smp->use_neff=0;


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movss 0x2cb4(%rip), %xmm0     # 0x9964
movss %xmm0, 0x14(%rax)
movq -0x10(%rbp), %rax
movss 0x2ca3(%rip), %xmm0     # 0x9964
movss %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
movss 0x2c92(%rip), %xmm0     # 0x9964
movss %xmm0, 0xc(%rax)
movq -0x10(%rbp), %rax
movss 0x2c81(%rip), %xmm0     # 0x9964
movss %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movss 0x2c70(%rip), %xmm0     # 0x9964
movss %xmm0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movss 0x2c5f(%rip), %xmm0     # 0x9964
movss %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x64(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c0(%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movss 0x2bc7(%rip), %xmm0     # 0x9964
movss %xmm0, 0xc(%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x14(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/lib/utils.c
// Function: time_stop
double time_stop(time_t t_time, clock_t c_clock){

	double aux1 = (clock() - c_clock) / (double)(CLOCKS_PER_SEC);
	double aux2 = difftime (time(NULL),t_time);
	
	printf("CLOCK = %lf TIME = %lf\n", aux1, aux2);
	
	return aux1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x20b0
subq -0x10(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0xd6d2(%rip), %xmm1     # 0x118b8
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x21c0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x2100
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
leaq 0xd786(%rip), %rdi      # 0x119a0
movb $0x2, %al
callq 0x20f0
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/lib/utils.c
// Function: dies
void dies(const char* where, char* format, ...) {

	int_t err = errno;
	va_list val;

	printf("Error at %s: %s.\n",where,errno ? strerror(errno) : "errno not set");
	va_start(val,format);
	vprintf(format,val);
	va_end(val);
	printf("\n");

	exit(err ? err : 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x42e8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2040
movslq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
callq 0x2040
cmpl $0x0, (%rax)
je 0x4342
callq 0x2040
movl (%rax), %edi
callq 0x2290
movq %rax, -0xf0(%rbp)
jmp 0x4352
leaq 0xd681(%rip), %rax      # 0x119ca
movq %rax, -0xf0(%rbp)
jmp 0x4352
movq -0xe8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
leaq 0xd651(%rip), %rdi      # 0x119b8
movb $0x0, %al
callq 0x20f0
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x21d0
leaq -0x30(%rbp), %rax
leaq 0xcdc3(%rip), %rdi      # 0x1116d
movb $0x0, %al
callq 0x20f0
cmpq $0x0, -0x18(%rbp)
je 0x43c5
movq -0x18(%rbp), %rax
movq %rax, -0xf8(%rbp)
jmp 0x43d3
movl $0x1, %eax
movq %rax, -0xf8(%rbp)
jmp 0x43d3
movq -0xf8(%rbp), %rax
movl %eax, %edi
callq 0x2270
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/lib/utils.c
// Function: print_char
int_t print_char(char* A, int_t n){

	int_t i;
	for(i=0; i<n; i++)	
		printf("%" PRIdN ") %c\n", i, A[i]);

	printf("\n");

return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x443e
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq 0xd5af(%rip), %rdi      # 0x119d8
movb $0x0, %al
callq 0x20f0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4408
leaq 0xcd28(%rip), %rdi      # 0x1116d
movb $0x0, %al
callq 0x20f0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/lib/utils.c
// Function: print_int
int_t print_int(int_t* A, int_t n){

	int_t i;
	for(i=0; i<n; i++)	
		printf("%" PRIdN ") %" PRIdN "\n", i, A[i]);

	printf("\n");

return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x44ae
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xd548(%rip), %rdi      # 0x119e1
movb $0x0, %al
callq 0x20f0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4478
leaq 0xccb8(%rip), %rdi      # 0x1116d
movb $0x0, %al
callq 0x20f0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/lib/utils.c
// Function: min_range
int_t min_range(int_t* A, int_t l, int_t r){


	if(r>l)return 0;

	printf("[l, r] = [%" PRIdN ", %" PRIdN "]\n", l, r);

	int_t min = INT_MAX;
	int_t i;
	for(i=l; i<=l; i++)
		min = (A[i]<min?A[i]:min);

	printf("min = %" PRIdN "\n", min);

return min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0x44fb
movq $0x0, -0x8(%rbp)
jmp 0x4587
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0xd4e1(%rip), %rdi      # 0x119eb
movb $0x0, %al
callq 0x20f0
movq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x456d
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x28(%rbp), %rax
jge 0x454f
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
jmp 0x4557
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4521
movq -0x28(%rbp), %rsi
leaq 0xd488(%rip), %rdi      # 0x11a00
movb $0x0, %al
callq 0x20f0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/lib/utils.c
// Function: cat_int
int_t* cat_int(unsigned char** R, int k, int_t *n){

	(*n)++; //add 0 at the end

	int_t i, j;
	int_t l=0;
	int_t *str_int = (int_t*) malloc((*n)*sizeof(int_t));

	for(i=0; i<k; i++){
		int_t m = strlen((char*)R[i]);
		for(j=0; j<m; j++){
			//removes symbols > 255
			if(R[i][j]+1<256) str_int[l++] = R[i][j]+(k+1);
			else (*n)--;
		}
//		for(j=0; j<m; j++)
//			str_int[l++] = R[i][j]+(k+1);
		str_int[l++] = i+1; //add $_i as separator
	}
	
	str_int[l++]=0;
        if(*n>l){
		str_int = (int_t*) realloc(str_int, (l)*sizeof(int_t));
		printf("N = %" PRIdN "\n", l);
	}
	*n = l;

return str_int;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
shlq $0x3, %rdi
callq 0x10960
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jge 0x46c1
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x20d0
movq %rax, -0x40(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x40(%rbp), %rax
jge 0x4691
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
addl $0x1, %eax
cmpl $0x100, %eax            # imm = 0x100
jge 0x4673
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
addl %ecx, %eax
movslq %eax, %rdx
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movq %rdx, (%rax,%rcx,8)
jmp 0x4681
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x4683
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4613
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x45e5
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x30(%rbp), %rax
jle 0x4710
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
shlq $0x3, %rsi
callq 0x10c50
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
leaq 0xd302(%rip), %rdi      # 0x11a0b
movb $0x0, %al
callq 0x20f0
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/lib/utils.c
// Function: cat_char
unsigned char* cat_char(unsigned char** R, int k, size_t *n){

	(*n)++; //add 0 at the end

	int_t i, j;
	int_t l=0;
	unsigned char *str = (unsigned char*) malloc((*n)*sizeof(unsigned char));

	for(i=0; i<k; i++){
		int_t m = strlen((char*)R[i]);
		//removes empty strings
		if(m==0){
			(*n)--;
			continue;
		}
		for(j=0; j<m; j++){
			//removes symbols > 255
			if(R[i][j]+1<256) str[l++] = R[i][j]+1;
			else (*n)--;
		}
		str[l++] = 1; //add 1 as separator
	}

	str[l++]=0;
  if(*n>l){
		str = (unsigned char*) realloc(str, (l)*sizeof(unsigned char));
		printf("N = %" PRIdN "\n", l);
	}
	*n = l;

return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
shlq $0x0, %rdi
callq 0x10960
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jge 0x49ec
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x20d0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x4945
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x49db
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x40(%rbp), %rax
jge 0x49c4
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
addl $0x1, %eax
cmpl $0x100, %eax            # imm = 0x100
jge 0x49a6
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
addl $0x1, %eax
movb %al, %dl
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x49b4
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x49b6
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x494d
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb $0x1, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4905
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x30(%rbp), %rax
jbe 0x4a37
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
shlq $0x0, %rsi
callq 0x10c50
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
leaq 0xcfdb(%rip), %rdi      # 0x11a0b
movb $0x0, %al
callq 0x20f0
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/lib/utils.c
// Function: sort
static void sort(char *array, size_t size, int (*cmp)(void*,void*), int begin, int end) {
   if (end > begin) {
      void *pivot = array + begin;
      int l = begin + size;
      int r = end;
      while(l < r) {
         if (cmp(array+l,pivot) <= 0) {
            l += size;
         } else if ( cmp(array+r, pivot) > 0 )  {
            r -= size;
         } else if ( l < r ) {
            swap2(array+l, array+r, size);
         }
      }
      l -= size;
      swap2(array+begin, array+l, size);
      sort(array, size, cmp, begin, l);
      sort(array, size, cmp, r, end);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x4bc4
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movslq -0x1c(%rbp), %rax
addq -0x10(%rbp), %rax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x4b67
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movslq -0x2c(%rbp), %rcx
addq %rcx, %rdi
movq -0x28(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jg 0x4b0d
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x2c(%rbp)
jmp 0x4b62
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rcx
addq %rcx, %rdi
movq -0x28(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jle 0x4b37
movq -0x10(%rbp), %rcx
movslq -0x30(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x30(%rbp)
jmp 0x4b60
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x4b5e
movq -0x8(%rbp), %rdi
movslq -0x2c(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x30(%rbp), %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x4d30
jmp 0x4b60
jmp 0x4b62
jmp 0x4ad7
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x2c(%rbp), %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x4d30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x2c(%rbp), %r8d
callq 0x4a90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x30(%rbp), %ecx
movl -0x20(%rbp), %r8d
callq 0x4a90
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/lib/utils.c
// Function: map
unsigned char map(unsigned char c){

  if(c==0) return 0; //$ and # symbols 

  switch(c){
    case 'A': 
    case 'a': c = 1<<5;
              break;

    case 'C':
    case 'c': c = 2<<5;
              break;

    case 'G': 
    case 'g': c = 3<<5;
              break;

    case 'T': 
    case 't': c = 4<<5;
              break;

    //including N
    default:  c = 5<<5;
              break;
  }

return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x0, %eax
jne 0x4be9
movb $0x0, -0x1(%rbp)
jmp 0x4c31
movzbl -0x2(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x33, %eax
ja 0x4c27
movq -0x10(%rbp), %rax
leaq 0xccba(%rip), %rcx      # 0x118c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x20, -0x2(%rbp)
jmp 0x4c2b
movb $0x40, -0x2(%rbp)
jmp 0x4c2b
movb $0x60, -0x2(%rbp)
jmp 0x4c2b
movb $-0x80, -0x2(%rbp)
jmp 0x4c2b
movb $-0x60, -0x2(%rbp)
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/lib/utils.c
// Function: unmap
unsigned char unmap(unsigned char c){

  c = c>>5;

  switch(c){
    case 1: c = 'a';
            break;

    case 2: c = 'c';
            break;

    case 3: c = 'g';
            break;

    case 4: c = 't';
            break;

    //including N
    default:  c = 'n';
              break;
  }

return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
shrl $0x5, %eax
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x4c91
movq -0x10(%rbp), %rax
leaq 0xcd20(%rip), %rcx      # 0x11990
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x61, -0x1(%rbp)
jmp 0x4c95
movb $0x63, -0x1(%rbp)
jmp 0x4c95
movb $0x67, -0x1(%rbp)
jmp 0x4c95
movb $0x74, -0x1(%rbp)
jmp 0x4c95
movb $0x6e, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/lib/utils.c
// Function: bwt
int bwt(int_t sa, unsigned char* str){

    int c;

    if(sa==0 || str[sa-1]==1)
      c = 0;
    else
      c = str[sa-1]-1;

return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4d08
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x4d11
movl $0x0, -0x14(%rbp)
jmp 0x4d27
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)