LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/thiagok00[P]INF1715-Compilers/GeraCodigo.c
// Function: gera_codigo_expas
static int gera_codigo_expas(Exp *e) {

  int idexp;

  idexp = gera_codigo_expressao(e->u.expnewas.exp);
  if (e->u.expnewas.exp->tipo->tipo_base == bInt && e->tipo->tipo_base == bFloat) {
      int idtemp = gen_id();
      //%2 = sitofp i32 %1 to float
      fprintf(output,"\t%%t%d = sitofp i32 %%t%d to float\n",idtemp,idexp);
      return idtemp;
  }
  //nao precisa de conversao
  return idexp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7b60
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x2, 0x4(%rax)
jne 0x88e7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x3, 0x4(%rax)
jne 0x88e7
callq 0x77b0
movl %eax, -0x18(%rbp)
movq 0x58bd(%rip), %rdi      # 0xe188
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x2503(%rip), %rsi      # 0xaddb
movb $0x0, %al
callq 0x10e0
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x88ed
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thiagok00[P]INF1715-Compilers/GeraCodigo.c
// Function: gera_codigo_expand
static int gera_codigo_expand(Exp *e) {

  int idexp,idtemp,labelTrue,labelFalse;

  idexp = gera_codigo_expressao(e->u.expbin.expesq);
  idtemp = gen_id();
  //  %t(idtemp) = icmp ne i32 %t(idexp), 0
  //  br i1 %3, label %4, label %8
  printf("\t%%t%d = icmp ne i32 %%t%d, 0",idtemp,idexp);
  labelTrue = gen_label();
  labelFalse = gen_label();
  printf("\tbr i1 %%t%d, label %%%d, label %%%d",idtemp,labelTrue,labelFalse);



  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7b60
movl %eax, -0xc(%rbp)
callq 0x77b0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x2635(%rip), %rdi      # 0xaf76
movb $0x0, %al
callq 0x10a0
callq 0x8e30
movl %eax, -0x14(%rbp)
callq 0x8e30
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x262c(%rip), %rdi      # 0xaf94
movb $0x0, %al
callq 0x10a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thiagok00[P]INF1715-Compilers/GeraCodigo.c
// Function: gera_codigo_expchamada
static int gera_codigo_expchamada(Exp *e) {
  int idtemp = -1;
  Tipo *tiporet = e->u.expchamada.def->tiporet;
  ExpL *expl;
  char paramString[200] = "";

  expl = e->u.expchamada.params;
  while (expl != NULL) {
    int expid;
    Tipo *exptipo;

    expid = gera_codigo_expressao(expl->e);
    exptipo = expl->e->tipo;
    if(expl->prox != NULL)
      sprintf(paramString,"%s%s %%t%d, ",paramString,tipo_string(exptipo),expid);
    else
      sprintf(paramString,"%s%s %%t%d",paramString,tipo_string(exptipo),expid);
    expl = expl->prox;
}

if(tiporet->tipo_base == bVoid){
  fprintf(output,"\tcall void @%s(",e->u.expchamada.idFunc);
}
else{
  //TODO ARRAYS
  idtemp = gen_id();
  fprintf(output,"\t%%t%d = call %s @%s(",idtemp,tipo_string(tiporet),e->u.expchamada.idFunc);
}
//fprintf(output,")\n");

fprintf(output,"%s)\n",paramString);
return idtemp;;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0xf0(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x10c0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8aad
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x7b60
movl %eax, -0xf4(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x100(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8a4e
leaq -0xf0(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x100(%rbp), %rdi
callq 0x7360
movq -0x110(%rbp), %rdi
movq -0x108(%rbp), %rdx
movq %rax, %rcx
movl -0xf4(%rbp), %r8d
leaq 0x205e(%rip), %rsi      # 0xaaa3
movb $0x0, %al
callq 0x1180
jmp 0x8a9c
leaq -0xf0(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x100(%rbp), %rdi
callq 0x7360
movq -0x120(%rbp), %rdi
movq -0x118(%rbp), %rdx
movq %rax, %rcx
movl -0xf4(%rbp), %r8d
leaq 0x2003(%rip), %rsi      # 0xaa98
movb $0x0, %al
callq 0x1180
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x89c4
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x8ad6
movq 0x56ca(%rip), %rdi      # 0xe188
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x24ec(%rip), %rsi      # 0xafb9
movb $0x0, %al
callq 0x10e0
jmp 0x8b24
callq 0x77b0
movl %eax, -0xc(%rbp)
movq 0x56a3(%rip), %rax      # 0xe188
movq %rax, -0x130(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x124(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7360
movq -0x130(%rbp), %rdi
movl -0x124(%rbp), %edx
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %r8
leaq 0x24ac(%rip), %rsi      # 0xafc9
movb $0x0, %al
callq 0x10e0
movq 0x565d(%rip), %rdi      # 0xe188
leaq -0xf0(%rbp), %rdx
leaq 0x24a6(%rip), %rsi      # 0xafdf
movb $0x0, %al
callq 0x10e0
movl -0xc(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/thiagok00[P]INF1715-Compilers/GeraCodigo.c
// Function: gera_codigo_expnew
static int gera_codigo_expnew(Exp *e) {

  int expid,idtemp,lastid,mult;

  expid = gera_codigo_expressao(e->u.expnewas.exp);
  idtemp = gen_id();
  if(e->tipo->tipo_base == bChar)
    mult = 1;
  else
    mult = 4;
  fprintf(output, "\t%%t%d = mul nsw i32 %%t%d, %d \n",idtemp,expid,mult);
  //%5 = sext i32 %4 to i64
  // lastid = idtemp;
  // idtemp = gen_id();
  // fprintf(output,"\t%%t%d = sext i32 %%t%d to i64\n",idtemp,lastid);

  //%t(expid) = call i8* @malloc(i64 10)
  lastid = idtemp;
  idtemp = gen_id();
  fprintf(output,"\t%%t%d = call i8* @malloc(i32 %%t%d)\n",idtemp,lastid);
  //%t(idtemp) = bitcast i8* %t(lastid) to i32*
  if(e->tipo->tipo_base != bChar) {
    lastid = idtemp;
    idtemp = gen_id();
    fprintf(output,"\t%%t%d = bitcast i8* %%t%d to i32*\n",idtemp,lastid);
  }
  return idtemp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7b60
movl %eax, -0xc(%rbp)
callq 0x77b0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0x4(%rax)
jne 0x8b8b
movl $0x1, -0x18(%rbp)
jmp 0x8b92
movl $0x4, -0x18(%rbp)
movq 0x55ef(%rip), %rdi      # 0xe188
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x18(%rbp), %r8d
leaq 0x243a(%rip), %rsi      # 0xafe4
movb $0x0, %al
callq 0x10e0
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x77b0
movl %eax, -0x10(%rbp)
movq 0x55c2(%rip), %rdi      # 0xe188
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x2432(%rip), %rsi      # 0xb005
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0x4(%rax)
je 0x8c11
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x77b0
movl %eax, -0x10(%rbp)
movq 0x558b(%rip), %rdi      # 0xe188
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x2421(%rip), %rsi      # 0xb02b
movb $0x0, %al
callq 0x10e0
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thiagok00[P]INF1715-Compilers/GeraCodigo.c
// Function: gera_codigo_strings
static void gera_codigo_strings() {
  printf("\n");
  while(strLst != NULL) {
    fprintf(output,"%s\n",strLst->s);
    strLst = strLst->prox;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x21a8(%rip), %rdi      # 0xb003
movb $0x0, %al
callq 0x10a0
cmpq $0x0, 0x5326(%rip)      # 0xe190
je 0x8e9f
movq 0x5315(%rip), %rdi      # 0xe188
movq 0x5316(%rip), %rax      # 0xe190
movq (%rax), %rdx
leaq 0x143a(%rip), %rsi      # 0xa2be
movb $0x0, %al
callq 0x10e0
movq 0x52fe(%rip), %rax      # 0xe190
movq 0x8(%rax), %rax
movq %rax, 0x52f3(%rip)      # 0xe190
jmp 0x8e62
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thiagok00[P]INF1715-Compilers/GeraCodigo.c
// Function: gera_declaracoes_iniciais
static void gera_declaracoes_iniciais() {
  fprintf(output,"target triple = \"x86_64-pc-linux-gnu\"");
	fprintf(output, "declare i8* @malloc(i32)\n" );
	fprintf(output, "declare i32 @printf(i8* nocapture readonly, ...)\n" );
	fprintf(output, "declare i32 @puts(i8* nocapture readonly)\n" );
  fprintf(output, "\n");
  fprintf(output, "@.intprint = private unnamed_addr constant [4 x i8] c\"%%d\\0A\\00\"\n");
	fprintf(output, "@.floatprint = private unnamed_addr constant [4 x i8] c\"%%f\\0A\\00\"\n" );
  fprintf(output,"\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x52cd(%rip), %rdi      # 0xe188
leaq 0x21cc(%rip), %rsi      # 0xb08e
movb $0x0, %al
callq 0x10e0
movq 0x52b8(%rip), %rdi      # 0xe188
leaq 0x21dd(%rip), %rsi      # 0xb0b4
movb $0x0, %al
callq 0x10e0
movq 0x52a3(%rip), %rdi      # 0xe188
leaq 0x21e2(%rip), %rsi      # 0xb0ce
movb $0x0, %al
callq 0x10e0
movq 0x528e(%rip), %rdi      # 0xe188
leaq 0x21ff(%rip), %rsi      # 0xb100
movb $0x0, %al
callq 0x10e0
movq 0x5279(%rip), %rdi      # 0xe188
leaq 0x20ed(%rip), %rsi      # 0xb003
movb $0x0, %al
callq 0x10e0
movq 0x5264(%rip), %rdi      # 0xe188
leaq 0x2200(%rip), %rsi      # 0xb12b
movb $0x0, %al
callq 0x10e0
movq 0x524f(%rip), %rdi      # 0xe188
leaq 0x222d(%rip), %rsi      # 0xb16d
movb $0x0, %al
callq 0x10e0
movq 0x523a(%rip), %rdi      # 0xe188
leaq 0x20ae(%rip), %rsi      # 0xb003
movb $0x0, %al
callq 0x10e0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/echo.c
// Function: parse_args
struct echo_args *parse_args(struct echo_args *args, int argc, char **argv){
    args->count = 0;
    if(argv[1][0] == '-'){    
        for(int i = 1; i < argc; i++){
            if(!strcmp(argv[i], "-n")){
                args->nonewline = true;
                args->count += 1;
            }
            else if(!strcmp(argv[i], "-e")){
                args->backslash = true;
                args->count += 1;
            }
            else if(!strcmp(argv[i], "-E")){
                args->backslash = false;
                args->count += 1;
            }
        }
    }
    return args;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1264
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1262
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xe3c(%rip), %rsi       # 0x2004
callq 0x1060
cmpl $0x0, %eax
jne 0x11e8
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x1252
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xe0c(%rip), %rsi       # 0x2007
callq 0x1060
cmpl $0x0, %eax
jne 0x121c
movq -0x8(%rbp), %rax
movb $0x1, 0x1(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x1250
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xddb(%rip), %rsi       # 0x200a
callq 0x1060
cmpl $0x0, %eax
jne 0x124e
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x1250
jmp 0x1252
jmp 0x1254
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11a9
jmp 0x1264
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/echo.c
// Function: main
int main(int argc, char **argv){
    struct echo_args *args = calloc(1, sizeof(struct echo_args));
    args = parse_args(args, argc, argv);
    if(argc == 1){
        putchar('\n');
        return 0;
    }
    for(int i = args->count + 1; i < argc; i++){
        printf("%s", argv[i]);
        if(i < argc - 1){
            putchar(' ');
        }
    }
    if(args->nonewline == false){
        putchar('\n');
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x8, %esi
callq 0x1050
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x1170
movq %rax, -0x18(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x12c6
movl $0xa, %edi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x133a
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1319
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xd1f(%rip), %rdi       # 0x200d
movb $0x0, %al
callq 0x1040
movl -0x1c(%rbp), %eax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x130c
movl $0x20, %edi
callq 0x1030
jmp 0x130e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12d3
movq -0x18(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1333
movl $0xa, %edi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/silence/silence.c
// Function: makeWindow
static int *
makeWindow()
    {
    int i;
    int *input = (int *) New(sizeof(int) * windowSize);

    for (i = 0; i < windowSize; ++i)
        input[i] = 0;

    return input;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movslq 0xe4e1(%rip), %rax      # 0x111b0
shlq $0x2, %rax
movl %eax, %edi
callq 0x91d0
movq %rax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xe4c2(%rip), %eax      # 0x111b0
jge 0x2d0a
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2ce5
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/silence/silence.c
// Function: rms
static double
rms(int count,int amp)
    {
    int index;
    static double last = 0;

    index = count % windowSize;

    last += amp * amp - window[index] * window[index];

    window[index] = amp;
        
    //printf("count is %d, amp is %d, last is %f, rms is %f\n",
        //count,amp,last,pow(last,0.5));
    //getchar();

    return pow(last,0.5);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl 0xe478(%rip)            # 0x111b0
movl %edx, -0xc(%rbp)
movl -0x8(%rbp), %eax
imull -0x8(%rbp), %eax
movq 0xe6ef(%rip), %rcx      # 0x11438
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movq 0xe6e1(%rip), %rdx      # 0x11438
movslq -0xc(%rbp), %rsi
imull (%rdx,%rsi,4), %ecx
subl %ecx, %eax
cvtsi2sd %eax, %xmm0
addsd 0xe6d3(%rip), %xmm0     # 0x11440
movsd %xmm0, 0xe6cb(%rip)     # 0x11440
movl -0x8(%rbp), %edx
movq 0xe6b9(%rip), %rax      # 0x11438
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movsd 0xe6b2(%rip), %xmm0     # 0x11440
movsd 0x928a(%rip), %xmm1     # 0xc020
callq 0x2080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/bareitem.c
// Function: SH_BareItem__to_s
sh_char_t*
SH_BareItem__to_s(SH_BareItem* obj, int* err) {
	sh_char_t* str;

	__cascade(err, (sh_char_t*)0);
	switch (obj->type) {
	case SH_NULL:
		str = (sh_char_t*)malloc(sizeof(sh_char_t));
		if ((sh_char_t*)0 == str) {
			__raise(err, SH_E_MALLOC_ERROR);
			return (sh_char_t*)0;
		}
		*str = SH_CHAR_C(0);
		return str;

	case SH_INTEGER:
		return SH_Integer__to_s((SH_Integer*)(obj->ptr), err);

	case SH_DECIMAL:
		return SH_Decimal__to_s((SH_Decimal*)(obj->ptr), err);

	case SH_STRING:
		return SH_String__to_s((SH_String*)(obj->ptr), err);

	case SH_TOKEN:
		return SH_Token__to_s((SH_Token*)(obj->ptr), err);

	case SH_BYTESEQUENCE:
		return SH_ByteSequence__to_s((SH_ByteSequence*)(obj->ptr), err);

	case SH_BOOLEAN:
		return SH_Boolean__to_s((SH_Boolean*)(obj->ptr), err);

	case SH_INNERLIST:
		return SH_InnerList__to_s((SH_InnerList*)(obj->ptr), err);

	/*default: fall out */
	}

	__raise(err, SH_E_ITEM_WRONG_TYPE);
	return (sh_char_t*)0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1d1f
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1d1f
movq $0x0, -0x8(%rbp)
jmp 0x1e51
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x7, %rax
ja 0x1e37
movq -0x28(%rbp), %rax
leaq 0x2e2(%rip), %rcx       # 0x2020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, %edi
callq 0x10c0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x1d7c
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1d6f
movq -0x18(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x1e51
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1e51
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1030
movq %rax, -0x8(%rbp)
jmp 0x1e51
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1070
movq %rax, -0x8(%rbp)
jmp 0x1e51
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10d0
movq %rax, -0x8(%rbp)
jmp 0x1e51
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10e0
movq %rax, -0x8(%rbp)
jmp 0x1e51
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1080
movq %rax, -0x8(%rbp)
jmp 0x1e51
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1120
movq %rax, -0x8(%rbp)
jmp 0x1e51
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1090
movq %rax, -0x8(%rbp)
jmp 0x1e51
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1e49
movq -0x18(%rbp), %rax
movl $0x100001, (%rax)       # imm = 0x100001
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/verificacion.c
// Function: Rbuit
void Rbuit(struct registro * reg) {
	//Inicializar todos los registros a 0
	reg->fecha = 0;
	reg->pid = 0;
	reg->nEscritura = 0;
	reg->posicion = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/verificacion.c
// Function: mostrarRegistro
void mostrarRegistro(struct registro *reg) {
	char fec[20];
	memset(fec,0,20);
	struct tm *ts;
	time_t t = reg->fecha;
	ts = localtime(&t);
	strftime(fec, sizeof(fec), "%Y/%m/%d %H:%M:%S", ts);
	printf("\t� Fecha: %s\n", fec);
	printf("\t� Numero escritura: %d\n", reg->nEscritura);
	printf("\t� Posicion: %d\n", reg->posicion);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x10c0
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1030
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rcx
movl $0x14, %esi
leaq 0x1652(%rip), %rdx      # 0x7559
callq 0x1150
leaq -0x20(%rbp), %rsi
leaq 0x1654(%rip), %rdi      # 0x756b
movb $0x0, %al
callq 0x10a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x164d(%rip), %rdi      # 0x7579
movb $0x0, %al
callq 0x10a0
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
leaq 0x1651(%rip), %rdi      # 0x7592
movb $0x0, %al
callq 0x10a0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/carlitosmarin[P]Sistema-Ficheros-SOII/verificacion.c
// Function: mostrarInfo
void mostrarInfo(struct informacion *info) {
	printf("PID: %d\n", info->proceso);
	printf("Registros validados: %d\n", info->nEscrituras);
	puts("Primera Escritura:");
	mostrarRegistro(&info->PrimeraEscritura);
	puts("Ultima Escritura:");
	mostrarRegistro(&info->UltimaEscritura);
	puts("Mayor Posicion:");
	mostrarRegistro(&info->MayorPosicion);
	puts("Menor Posicion:");
	mostrarRegistro(&info->MenorPosicion);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0x163a(%rip), %rdi      # 0x75a3
movb $0x0, %al
callq 0x10a0
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x162e(%rip), %rdi      # 0x75ac
movb $0x0, %al
callq 0x10a0
leaq 0x1639(%rip), %rdi      # 0x75c5
callq 0x1060
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x5ec0
leaq 0x1633(%rip), %rdi      # 0x75d8
callq 0x1060
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x5ec0
leaq 0x162c(%rip), %rdi      # 0x75ea
callq 0x1060
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x5ec0
leaq 0x1623(%rip), %rdi      # 0x75fa
callq 0x1060
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x5ec0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Arlu[P]RDMA-Hello-World/server.c
// Function: chat
void chat()
{
    struct RemoteMR remote_mr;

    // Get Hello World via send and receive request:
    post_recv(BUFFER_SIZE);
    wait_completions(RECV_WRID);

    printf(ib_res.buf);

    // Get remote address and rkey:
    post_recv(sizeof(struct RemoteMR));
    wait_completions(RECV_WRID);
    memcpy(&remote_mr, ib_res.buf, sizeof(struct RemoteMR));

    // Get Hello World via RDMA Read:
    post_recv(1); // Wait to the client for read ready:
    wait_completions(RECV_WRID);
    post_send_read(remote_mr, BUFFER_SIZE);
    wait_completions(READ_WRID);

    printf(ib_res.buf);

    // Send remote address and rkey:
    remote_mr.remote_addr = (uint64_t)ib_res.buf;
    remote_mr.rkey = ib_res.mr->rkey;
    memcpy(ib_res.buf, &remote_mr, sizeof(struct RemoteMR));
    post_send(sizeof(struct RemoteMR));
    wait_completions(SEND_WRID);

    // Wait to the client for Send Hello World via RDMA Write:
    post_recv(1);
    wait_completions(RECV_WRID);

    printf(ib_res.buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x400, %edi            # imm = 0x400
callq 0x2010
movl $0x1, %edi
callq 0x23b0
leaq 0x3dbd(%rip), %rax      # 0x5190
movq 0x60(%rax), %rdi
movb $0x0, %al
callq 0x10d0
movl $0x10, %edi
callq 0x2010
movl $0x1, %edi
callq 0x23b0
leaq 0x3d97(%rip), %rax      # 0x5190
movq 0x60(%rax), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x1, %edi
callq 0x2010
movl $0x1, %edi
callq 0x23b0
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
movl $0x400, %edx            # imm = 0x400
callq 0x21b0
movl $0x4, %edi
callq 0x23b0
leaq 0x3d4e(%rip), %rax      # 0x5190
movq 0x60(%rax), %rdi
movb $0x0, %al
callq 0x10d0
leaq 0x3d3c(%rip), %rax      # 0x5190
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x3d2d(%rip), %rax      # 0x5190
movq 0x10(%rax), %rax
movl 0x28(%rax), %eax
movl %eax, -0x8(%rbp)
leaq 0x3d1c(%rip), %rax      # 0x5190
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x10, %edi
callq 0x20d0
movl $0x2, %edi
callq 0x23b0
movl $0x1, %edi
callq 0x2010
movl $0x1, %edi
callq 0x23b0
leaq 0x3cda(%rip), %rax      # 0x5190
movq 0x60(%rax), %rdi
movb $0x0, %al
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Arlu[P]RDMA-Hello-World/server.c
// Function: main
int main(int argc, char *argv[])
{
    server_name = NULL;

    if (setup_ib())
    {
        perror("Failed to setup IB.");
    }

    chat();

    close_ib_connection();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x3c83(%rip), %rax      # 0x5170
movq $0x0, (%rax)
movb $0x0, %al
callq 0x1990
cmpl $0x0, %eax
je 0x150c
leaq 0x1afd(%rip), %rdi      # 0x3004
callq 0x1200
callq 0x13b0
movb $0x0, %al
callq 0x1f40
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/fic.c
// Function: main
int main(void)
{
    long fi;

    require64BitLongs();

    runtime_init();
    lexer_init();

    fi = parse();

    print(fi);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x4000
callq 0x3f00
callq 0x2300
callq 0x2310
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2370
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: hackedIntCast
int hackedIntCast(char c){
  if(c == '0'){return 0;}
  if(c == '1'){return 1;}
  if(c == '2'){return 2;}
  if(c == '3'){return 3;}
  if(c == '4'){return 4;}
  if(c == '5'){return 5;}
  if(c == '6'){return 6;}
  if(c == '7'){return 7;}
  if(c == '8'){return 8;}
  if(c == '9'){return 9;}
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jne 0x431f
movl $0x0, -0x4(%rbp)
jmp 0x43ce
movsbl -0x5(%rbp), %eax
cmpl $0x31, %eax
jne 0x4334
movl $0x1, -0x4(%rbp)
jmp 0x43ce
movsbl -0x5(%rbp), %eax
cmpl $0x32, %eax
jne 0x4349
movl $0x2, -0x4(%rbp)
jmp 0x43ce
movsbl -0x5(%rbp), %eax
cmpl $0x33, %eax
jne 0x435b
movl $0x3, -0x4(%rbp)
jmp 0x43ce
movsbl -0x5(%rbp), %eax
cmpl $0x34, %eax
jne 0x436d
movl $0x4, -0x4(%rbp)
jmp 0x43ce
movsbl -0x5(%rbp), %eax
cmpl $0x35, %eax
jne 0x437f
movl $0x5, -0x4(%rbp)
jmp 0x43ce
movsbl -0x5(%rbp), %eax
cmpl $0x36, %eax
jne 0x4391
movl $0x6, -0x4(%rbp)
jmp 0x43ce
movsbl -0x5(%rbp), %eax
cmpl $0x37, %eax
jne 0x43a3
movl $0x7, -0x4(%rbp)
jmp 0x43ce
movsbl -0x5(%rbp), %eax
cmpl $0x38, %eax
jne 0x43b5
movl $0x8, -0x4(%rbp)
jmp 0x43ce
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jne 0x43c7
movl $0x9, -0x4(%rbp)
jmp 0x43ce
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: lnfact2
double lnfact2(double input){
  double input2 = input*input;
  double input3 = input*input2;
  double input5 = input3*input2;
  double input7 = input5*input2;
  return (input - 0.5)*log(input) - input + lnfactconst2 + 1.0/(12.0*input) - 1.0/(360.0*input3) + 1.0/(1260.0*input5) - 1.0/(1680.0*input7);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x2763a(%rip), %xmm1    # 0x2ba70
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x3280
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x275eb(%rip), %xmm1    # 0x2ba68
addsd %xmm1, %xmm0
movsd 0x275d7(%rip), %xmm2    # 0x2ba60
mulsd -0x8(%rbp), %xmm2
movsd 0x275aa(%rip), %xmm1    # 0x2ba40
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd 0x275b2(%rip), %xmm2    # 0x2ba58
mulsd -0x18(%rbp), %xmm2
movsd 0x2758d(%rip), %xmm1    # 0x2ba40
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd 0x2758d(%rip), %xmm2    # 0x2ba50
mulsd -0x20(%rbp), %xmm2
movsd 0x27570(%rip), %xmm1    # 0x2ba40
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd 0x27568(%rip), %xmm2    # 0x2ba48
mulsd -0x28(%rbp), %xmm2
movsd 0x27553(%rip), %xmm1    # 0x2ba40
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: getNegBinomZnorm
double getNegBinomZnorm(double r){
  double ans = 0.0;
  int n = 0;
  double diff = 1.0;
  while((diff > 1e-8 || n < r) && n < 10000000){
      diff = exp(2.0*lnfact2(r + (double)n) - 2.0*lnfact2(r) - 2.0*lnfact2((double)n + 1.0) + (r + (double)n)*log(4.0));
      ans += diff;
      n++;
  }
  return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movsd 0x2751c(%rip), %xmm0    # 0x2ba40
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x27542(%rip), %xmm1    # 0x2ba78
ucomisd %xmm1, %xmm0
ja 0x4551
cvtsi2sdl -0x14(%rbp), %xmm1
movsd -0x8(%rbp), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x21(%rbp)
jbe 0x455e
cmpl $0x989680, -0x14(%rbp)  # imm = 0x989680
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x456a
jmp 0x464b
movsd -0x8(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
addsd %xmm1, %xmm0
callq 0x43e0
movsd %xmm0, -0x48(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x43e0
movaps %xmm0, %xmm2
movsd -0x48(%rbp), %xmm0
movsd 0x274ec(%rip), %xmm1    # 0x2ba88
mulsd %xmm2, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
cvtsi2sdl -0x14(%rbp), %xmm0
movsd 0x2746f(%rip), %xmm1    # 0x2ba40
addsd %xmm1, %xmm0
callq 0x43e0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
addsd %xmm1, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x8(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x27476(%rip), %xmm0    # 0x2ba80
callq 0x3280
movsd -0x38(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x3680
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4529
movsd -0x10(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: GetInsertProbNormal
double GetInsertProbNormal(double point, const double sigma){
  if (sigma == 0.0){
      return 1.0;
  }
  double p1 = erf((point + 0.5)/sqrt(2*sigma*sigma));
  double p2 = erf((point - 0.5)/sqrt(2*sigma*sigma));
  double prob = 0.5*(p1 - p2);
  ////printf("Point: %lf, p1: %lf, p2: %lf = %lf\n", point, erf((point + 0.5)/sqrt(2*sigma*sigma)), erf((point - 0.5)/sqrt(2*sigma*sigma)), prob);
  return prob;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4714
jp 0x4714
movsd 0x27336(%rip), %xmm0    # 0x2ba40
movsd %xmm0, -0x8(%rbp)
jmp 0x47bb
movsd 0x27354(%rip), %xmm0    # 0x2ba70
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x2735a(%rip), %xmm0    # 0x2ba88
mulsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
callq 0x35f0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
divsd %xmm1, %xmm0
callq 0x3060
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x27310(%rip), %xmm1    # 0x2ba70
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x27317(%rip), %xmm0    # 0x2ba88
mulsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
callq 0x35f0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
divsd %xmm1, %xmm0
callq 0x3060
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm1
subsd -0x28(%rbp), %xmm1
movsd 0x272c8(%rip), %xmm0    # 0x2ba70
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: getMD
char *getMD(bam1_t *bam, char *ref) {
    char *md = (char*) bam_aux_get(bam, "MD");
    if (md == NULL) {
        bam_fillmd1_core_ALE(bam, ref);
        md = (char*) bam_aux_get(bam, "MD");
    }
    return md;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2b599(%rip), %rsi     # 0x2fdb4
callq 0x14890
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x484c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a2b0
movq -0x8(%rbp), %rdi
leaq 0x2b571(%rip), %rsi     # 0x2fdb4
callq 0x14890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: getInsertLikelihoodBAM
double getInsertLikelihoodBAM(bam1_t *read1, double mu, double sigma){
  assert(read1 != NULL);
  double mapLength = (double)getFragmentMapLenBAM(read1);
  assert(mapLength > 0.0);
  double likelihood = GetInsertProbNormal(fabs(mapLength - mu), sigma);
  //printf("getInsertLikelihoodBAM(%lf,%lf,%lf): %e\n",fabs(mapLength - mu), mu, sigma,likelihood);
  assert(likelihood >= 0.0 && likelihood <= 1.0);
  return likelihood;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x487f
jmp 0x489e
leaq 0x2b531(%rip), %rdi     # 0x2fdb7
leaq 0x2b538(%rip), %rsi     # 0x2fdc5
movl $0x8c, %edx
leaq 0x2b536(%rip), %rcx     # 0x2fdcf
callq 0x3220
movq -0x8(%rbp), %rdi
callq 0xddf0
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x48c0
jmp 0x48df
leaq 0x2b540(%rip), %rdi     # 0x2fe07
leaq 0x2b4f7(%rip), %rsi     # 0x2fdc5
movl $0x8e, %edx
leaq 0x2b4f5(%rip), %rcx     # 0x2fdcf
callq 0x3220
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movaps 0x27200(%rip), %xmm1    # 0x2baf0
pand %xmm1, %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x46e0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4922
movsd 0x27127(%rip), %xmm0    # 0x2ba40
ucomisd -0x28(%rbp), %xmm0
jb 0x4922
jmp 0x4941
leaq 0x2b4ee(%rip), %rdi     # 0x2fe17
leaq 0x2b495(%rip), %rsi     # 0x2fdc5
movl $0x91, %edx
leaq 0x2b493(%rip), %rcx     # 0x2fdcf
callq 0x3220
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: loglikeMiss
double loglikeMiss(char *readQual, int seqPos, int missLen, int qOff){
  int i;
  double loglikelihood = 0.0;
  for(i = seqPos; i < seqPos + missLen; i++){
    //likelihood = likelihood*((1.0 - 0.99)/3.0);
    //likelihood = likelihood*((1.0 - getQtoP(readQual[i], qOff))/3.0); // sometimes want -33/64?
    double logp = getQtoLogPMiss(readQual[i], qOff);
    ////printf("likeMiss(%d, %d, %c): %lf %lf %lf %lf\n", missLen, i, readQual[i] + 33, logp, loglikelihood, exp(logp), exp(loglikelihood));
    loglikelihood += logp;
  }
  ////printf("loglikeMiss(%d): %e\n", missLen, loglikelihood);
  assert(loglikelihood <= 0.0);
  return loglikelihood;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0x49b5
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movl -0x14(%rbp), %esi
movsbl %al, %edi
callq 0xc060
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4973
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jb 0x49c1
jmp 0x49e0
leaq 0x2b476(%rip), %rdi     # 0x2fe3e
leaq 0x2b3f6(%rip), %rsi     # 0x2fdc5
movl $0xa1, %edx
leaq 0x2b478(%rip), %rcx     # 0x2fe53
callq 0x3220
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: loglikeMatch
double loglikeMatch(char *readQual, int seqPos, int matchLen, int qOff){
  int i;
  double loglikelihood = 0.0;
  for(i = seqPos; i < seqPos + matchLen; i++){
    loglikelihood += getQtoLogP(readQual[i], qOff);// sometimes want -33/64?
    ////printf("likeMatch %d %d %f %f %f\n", i, readQual[i], QtoLogP[readQual[i] - qOff], getQtoLogP(readQual[i], qOff), loglikelihood);
  }
  ////printf("loglikeMatch(%d): %e\n", matchLen, loglikelihood);
  assert(loglikelihood <= 0.0);
  return loglikelihood;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0x4a4b
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movl -0x14(%rbp), %esi
movsbl %al, %edi
callq 0xbff0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4a13
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jb 0x4a57
jmp 0x4a76
leaq 0x2b3e0(%rip), %rdi     # 0x2fe3e
leaq 0x2b360(%rip), %rsi     # 0x2fdc5
movl $0xae, %edx
leaq 0x2b40c(%rip), %rcx     # 0x2fe7d
callq 0x3220
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: loglikeDeletion
double loglikeDeletion(char *readQual, int seqPos, int deletionLength, int qOff, int readLen) {
  // assume as unlikely as a substitution of previous base
  // TODO refine
  int delPos = (seqPos > 0) ? seqPos - 1 : seqPos;
  assert(delPos >= 0);
  double loglikelihood = loglikeMiss(readQual, delPos, 1, qOff) * (double)deletionLength;
  if (seqPos > 0 && delPos+1 < readLen) {
    loglikelihood += loglikeMiss(readQual, delPos+1, 1, qOff) * (double)deletionLength;
    loglikelihood /= 2.0;
  }
  ////printf("loglikeDeletion(%d): %e\n", deletionLength, loglikelihood);
  return loglikelihood;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x4afa
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4b00
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x4b0e
jmp 0x4b2d
leaq 0x2b393(%rip), %rdi     # 0x2fea8
leaq 0x2b2a9(%rip), %rsi     # 0x2fdc5
movl $0xc0, %edx
leaq 0x2b38c(%rip), %rcx     # 0x2feb4
callq 0x3220
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x14(%rbp), %ecx
movl $0x1, %edx
callq 0x4950
cvtsi2sdl -0x10(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x4ba4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cmpl -0x18(%rbp), %eax
jge 0x4ba4
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
addl $0x1, %esi
movl -0x14(%rbp), %ecx
movl $0x1, %edx
callq 0x4950
cvtsi2sdl -0x10(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x26eed(%rip), %xmm1    # 0x2ba88
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: getBaseAmbibuity
int getBaseAmbibuity (char c) {
   int ambiguity = 0;
   switch(c) {
       // a real base
       case 'A':
       case 'T':
       case 'U':
       case 'C':
       case 'G': ambiguity = 1; break;
       // an ambiguity base
       case 'N': ambiguity = 4; break;
       case 'M':
       case 'R':
       case 'W':
       case 'S':
       case 'Y':
       case 'K': ambiguity = 2; break;
       case 'V':
       case 'H':
       case 'D':
       case 'B': ambiguity = 3; break;
       default: break;
   }
   return ambiguity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x0, -0x8(%rbp)
movsbl -0x1(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x18, %eax
ja 0x4c0b
movq -0x10(%rbp), %rax
leaq 0x26f22(%rip), %rcx     # 0x2bb00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x8(%rbp)
jmp 0x4c0d
movl $0x4, -0x8(%rbp)
jmp 0x4c0d
movl $0x2, -0x8(%rbp)
jmp 0x4c0d
movl $0x3, -0x8(%rbp)
jmp 0x4c0d
jmp 0x4c0d
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: getSeqPosForAlignment
int getSeqPosForAlignment(bam1_t *read) {
	int seqPos = 0;
	uint32_t *cigar = bam1_cigar(read);
	int numCigarOperations = read->core.n_cigar;
    uint32_t cigarInt = *(cigar);
    uint32_t cigarFlag = (cigarInt & BAM_CIGAR_MASK);
    uint32_t count = (cigarInt >> BAM_CIGAR_SHIFT);
    if (cigarFlag == BAM_CSOFT_CLIP)
    	seqPos += count;
    return seqPos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x18, %rcx
andq $0xff, %rcx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x30, %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
shrl $0x4, %eax
movl %eax, -0x28(%rbp)
cmpl $0x4, -0x24(%rbp)
jne 0x4e2d
movl -0x28(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: getMatchLogLikelihoodBAM
double getMatchLogLikelihoodBAM(bam1_t *read, contig_t *contig, int qOff, int alignmentLength) {
	float depthContributions[alignmentLength];
	double placeLogLikelihoods[alignmentLength];
	int i;
	double loglikelihood = getContributionsForPositions(read, contig, qOff, alignmentLength, depthContributions, placeLogLikelihoods, 1);

	for(i = 0; i < alignmentLength ; i++)
		loglikelihood += placeLogLikelihoods[i];

	loglikelihood = validateLogLikelihood( loglikelihood );
	return loglikelihood;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
movq %rsp, %r8
subq %rcx, %r8
movq %r8, %rsp
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %r9
subq %rcx, %r9
movq %r9, -0x48(%rbp)
movq %r9, %rsp
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
subq $0x10, %rsp
movl $0x1, (%rsp)
callq 0x4e40
addq $0x10, %rsp
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5981
movq -0x48(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5957
movsd -0x40(%rbp), %xmm0
callq 0xbe00
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: kmerHash
int kmerHash(char c1, int place){
  int hash = 0;
  switch(c1) {
  case 'A': case 'a': break;
  case 'T': case 't': hash = 0x1 << (place*2); break;
  case 'C': case 'c': hash = 0x2 << (place*2); break;
  case 'G': case 'g': hash = 0x3 << (place*2); break;
  default: hash = -16777216;
  }
  return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movsbl -0x1(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x33, %eax
ja 0x5a1f
movq -0x18(%rbp), %rax
leaq 0x261fb(%rip), %rcx     # 0x2bbdc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x5a26
movl -0x8(%rbp), %ecx
shll %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0xc(%rbp)
jmp 0x5a26
movl -0x8(%rbp), %ecx
shll %ecx
movl $0x2, %eax
shll %cl, %eax
movl %eax, -0xc(%rbp)
jmp 0x5a26
movl -0x8(%rbp), %ecx
shll %ecx
movl $0x3, %eax
shll %cl, %eax
movl %eax, -0xc(%rbp)
jmp 0x5a26
movl $0xff000000, -0xc(%rbp) # imm = 0xFF000000
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: getKmerHash
int getKmerHash(char *seq, int startPos, int kmerLen){
  int i;
  int hash = 0;
  for(i = 0; i < kmerLen; i++){
    hash += kmerHash(seq[startPos+i], i);
  }
  return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x5a84
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movl -0x14(%rbp), %esi
movsbl %al, %edi
callq 0x59b0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5a50
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: JSHash
unsigned int JSHash(char* str)
{
  unsigned int hash = 1315423911;
  char c;

  while (str != NULL && (c=*str++) != '\0')
  {
    hash ^= ((hash << 5) + c + (hash >> 2));
  }

  return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x4e67c6a7, -0xc(%rbp) # imm = 0x4E67C6A7
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0xe(%rbp)
je 0x63bb
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0xd(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
testb $0x1, %al
jne 0x63c4
jmp 0x63e0
movl -0xc(%rbp), %eax
shll $0x5, %eax
movsbl -0xd(%rbp), %ecx
addl %ecx, %eax
movl -0xc(%rbp), %ecx
shrl $0x2, %ecx
addl %ecx, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x638f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALElike.c
// Function: getTotalLikelihood
double getTotalLikelihood(alignSet_t *head) {
  double likeNormalizer = 0.0;
  likeNormalizer += head->likelihood*head->likelihoodInsert;
  alignSet_t *current = head;
  while(current->nextAlignment != NULL){
    current = current->nextAlignment;
    likeNormalizer += current->likelihood*current->likelihoodInsert;
  }
  return likeNormalizer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm2
movsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x6467
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm2
movsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x642b
movsd -0x10(%rbp), %xmm0
popq %rbp
retq
nop