LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/fanf2[P]luajit-2/src/buildvm_fold.c
// Function: foldrule
static void foldrule(char *p)
{
  uint32_t op = nexttoken(&p, 0, 0);
  uint32_t left = nexttoken(&p, 0, 1);
  uint32_t right = nexttoken(&p, 1, 1);
  uint32_t key = (funcidx << 24) | (op << 16) | (left << 8) | right;
  uint32_t i;
  if (nkeys >= BUILD_MAX_FOLD) {
    fprintf(stderr, "Error: too many fold rules, increase BUILD_MAX_FOLD.\n");
    exit(1);
  }
  /* Simple insertion sort to detect duplicates. */
  for (i = nkeys; i > 0; i--) {
    if ((foldkeys[i-1]&0xffffff) < (key & 0xffffff))
      break;
    if ((foldkeys[i-1]&0xffffff) == (key & 0xffffff)) {
      fprintf(stderr, "Error: duplicate fold definition at line %d\n", lineno);
      exit(1);
    }
    foldkeys[i] = foldkeys[i-1];
  }
  foldkeys[i] = key;
  nkeys++;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xe4d0
movl %eax, 0x1c(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xe4d0
movl %eax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xe4d0
movl %eax, 0x14(%rsp)
movl 0xc069(%rip), %eax      # 0x1a284
shll $0x18, %eax
movl 0x1c(%rsp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl 0x18(%rsp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
orl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
cmpl $0x1000, 0xc046(%rip)   # imm = 0x1000
jb 0xe266
movq 0x9dad(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
leaq 0x6bca(%rip), %rsi      # 0x14e1f
movb $0x0, %al
callq 0x4110
movl $0x1, %edi
callq 0x4190
movl 0xc01c(%rip), %eax      # 0x1a288
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jbe 0xe32d
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xc003(%rip), %rax      # 0x1a290
movl (%rax,%rcx,4), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl 0x10(%rsp), %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
cmpl %ecx, %eax
jae 0xe2a8
jmp 0xe32d
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xbfd6(%rip), %rax      # 0x1a290
movl (%rax,%rcx,4), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl 0x10(%rsp), %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
cmpl %ecx, %eax
jne 0xe2f8
movq 0x9d21(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
movl 0xbfa0(%rip), %edx      # 0x1a280
leaq 0x6b6e(%rip), %rsi      # 0x14e55
movb $0x0, %al
callq 0x4110
movl $0x1, %edi
callq 0x4190
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xbf86(%rip), %rax      # 0x1a290
movl (%rax,%rcx,4), %edx
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0xbf76(%rip), %rax      # 0x1a290
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xe270
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0xbf52(%rip), %rax      # 0x1a290
movl %edx, (%rax,%rcx,4)
movl 0xbf41(%rip), %eax      # 0x1a288
addl $0x1, %eax
movl %eax, 0xbf38(%rip)      # 0x1a288
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/fcollect.c
// Function: main
int
main(void)
{
    int npes;
    int me;
    int *dst;
    int i;

    shmem_init();
    npes = shmem_n_pes();
    me = shmem_my_pe();

    dst = (int *) shmem_malloc(64);

    for (i = 0; i < 4; i++) {
        dst[i] = 10101;
    }
    src = me + 100;

    printf("%8s: dst[%d/%d] = %d, %d, %d, %d\n",
           "BEFORE", me, npes, dst[0], dst[1], dst[2], dst[3]);

    for (i = 0; i < SHMEM_BCAST_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }
    shmem_barrier_all();

    shmem_fcollect32(dst, &src, 1, 0, 0, npes, pSync);

    shmem_barrier_all();

    /*
     * end state of "dst" = 100, 101, 102, ...
     */

    printf("%8s: dst[%d/%d] = %d, %d, %d, %d\n",
           "AFTER", me, npes, dst[0], dst[1], dst[2], dst[3]);

    shmem_free(dst);

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
callq 0x10a0
callq 0x1040
movl %eax, 0x30(%rsp)
callq 0x1070
movl %eax, 0x2c(%rsp)
movl $0x40, %edi
callq 0x1080
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jge 0x121f
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl $0x2775, (%rax,%rcx,4)  # imm = 0x2775
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x11fa
movl 0x2c(%rsp), %eax
addl $0x64, %eax
movl %eax, 0x2e54(%rip)      # 0x4080
movl 0x2c(%rsp), %edx
movl 0x30(%rsp), %ecx
movq 0x20(%rsp), %rax
movl (%rax), %r8d
movq 0x20(%rsp), %rax
movl 0x4(%rax), %r9d
movq 0x20(%rsp), %rax
movl 0x8(%rax), %r10d
movq 0x20(%rsp), %rax
movl 0xc(%rax), %eax
leaq 0xda7(%rip), %rdi       # 0x2004
leaq 0xdc2(%rip), %rsi       # 0x2026
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x1030
movl $0x0, 0x1c(%rsp)
cmpl $0x2, 0x1c(%rsp)
jge 0x12a3
movslq 0x1c(%rsp), %rcx
leaq 0x2e02(%rip), %rax      # 0x4090
movq $-0x1, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x127b
callq 0x1090
movq 0x20(%rsp), %rdi
movl 0x30(%rsp), %r9d
leaq 0x2dc7(%rip), %rsi      # 0x4080
movl $0x1, %edx
xorl %r8d, %r8d
leaq 0x2dc8(%rip), %rax      # 0x4090
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x1050
callq 0x1090
movl 0x2c(%rsp), %edx
movl 0x30(%rsp), %ecx
movq 0x20(%rsp), %rax
movl (%rax), %r8d
movq 0x20(%rsp), %rax
movl 0x4(%rax), %r9d
movq 0x20(%rsp), %rax
movl 0x8(%rax), %r10d
movq 0x20(%rsp), %rax
movl 0xc(%rax), %eax
leaq 0xcfa(%rip), %rdi       # 0x2004
leaq 0xd1c(%rip), %rsi       # 0x202d
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x1030
movq 0x20(%rsp), %rdi
callq 0x10b0
callq 0x1060
xorl %eax, %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_int_atomic_compare_swap.c
// Function: shmem_int_atomic_compare_swap
int shmem_int_atomic_compare_swap( int* ptr, int cond, int val, int pe)
{
	int* remote_ptr = (int*)shmem_ptr((void*)ptr, pe ); 
	long* x = (long*)shmem_ptr((void*)&__shmem.lock_atomic_int, pe);
	__set_spin_lock(x);
	int r = *remote_ptr;
	if (r == cond) *remote_ptr = val;
	__clear_spin_lock(x);
	return r;
}

// 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)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1fc0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %esi
leaq 0x3021(%rip), %rdi      # 0x71e0
addq $0x10, %rdi
callq 0x1fc0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4540
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x41ef
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x4500
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/main.c
// Function: getCompleteChecksum
short int getCompleteChecksum(ubx_message ptr_ubx){
  // Algorithme de Fletcher: voir page 86 de u-blox6 receiver description protocol

  unsigned char a, b;
  unsigned short int length = (ptr_ubx.message_length[1]<<8)|ptr_ubx.message_length[0];
  a = 0x00;
  b = 0x00;
  a = b + ptr_ubx.message_class;
  b = b + a;
  a = a + ptr_ubx.message_id;
  b = b + a;
  a = a + ptr_ubx.message_length[0];
  b = b + a;
  a = a + ptr_ubx.message_length[1];
  b = b + a;
  for(int i=0; i<length; i++){
    a = a + ptr_ubx.payload[i];
    b = b + a;
  }
  if(a == ptr_ubx.checksum_A && b == ptr_ubx.checksum_B){
    return 0;

  }else{
    return 1;
  }
  //checksum(ptr_ubx.id[0], ptr_ubx->checksum_A, ptr_ubx->checksum_B);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movzbl 0x5(%rcx), %eax
shll $0x8, %eax
movzbl 0x4(%rcx), %edx
orl %edx, %eax
movw %ax, -0x6(%rbp)
movb $0x0, -0x3(%rbp)
movb $0x0, -0x4(%rbp)
movzbl -0x4(%rbp), %eax
movzbl 0x2(%rcx), %edx
addl %edx, %eax
movb %al, -0x3(%rbp)
movzbl -0x4(%rbp), %eax
movzbl -0x3(%rbp), %edx
addl %edx, %eax
movb %al, -0x4(%rbp)
movzbl -0x3(%rbp), %eax
movzbl 0x3(%rcx), %edx
addl %edx, %eax
movb %al, -0x3(%rbp)
movzbl -0x4(%rbp), %eax
movzbl -0x3(%rbp), %edx
addl %edx, %eax
movb %al, -0x4(%rbp)
movzbl -0x3(%rbp), %eax
movzbl 0x4(%rcx), %edx
addl %edx, %eax
movb %al, -0x3(%rbp)
movzbl -0x4(%rbp), %eax
movzbl -0x3(%rbp), %edx
addl %edx, %eax
movb %al, -0x4(%rbp)
movzbl -0x3(%rbp), %eax
movzbl 0x5(%rcx), %ecx
addl %ecx, %eax
movb %al, -0x3(%rbp)
movzbl -0x4(%rbp), %eax
movzbl -0x3(%rbp), %ecx
addl %ecx, %eax
movb %al, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movzwl -0x6(%rbp), %ecx
cmpl %ecx, %eax
jge 0x139d
movq -0x18(%rbp), %rcx
movzbl -0x3(%rbp), %eax
movslq -0xc(%rbp), %rdx
movzbl 0x6(%rcx,%rdx), %ecx
addl %ecx, %eax
movb %al, -0x3(%rbp)
movzbl -0x4(%rbp), %eax
movzbl -0x3(%rbp), %ecx
addl %ecx, %eax
movb %al, -0x4(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1364
movq -0x18(%rbp), %rcx
movzbl -0x3(%rbp), %eax
movzbl 0x3ee(%rcx), %ecx
cmpl %ecx, %eax
jne 0x13cb
movq -0x18(%rbp), %rcx
movzbl -0x4(%rbp), %eax
movzbl 0x3ef(%rcx), %ecx
cmpl %ecx, %eax
jne 0x13cb
movw $0x0, -0x2(%rbp)
jmp 0x13d1
movw $0x1, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/main.c
// Function: displayHelp
void displayHelp(){
  printf("\nuBlox Lib Version 0.0.1\n\n");
  
  printf("Arguments :\n");
  printf("-h : display this help (optional)\n");
  printf("-i : set input file (mandatory)\n");
  printf("-m : parse a specific message (optional)\n");
  printf("-o : set output file (mandatory)\n");
  printf("-p : plot charts\n");
  printf("-r : generate a report after parsing the ubx file(optional)\n");
  printf("-v : get program version\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2c75(%rip), %rdi      # 0x4060
movb $0x0, %al
callq 0x10b0
leaq 0x2c82(%rip), %rdi      # 0x407b
movb $0x0, %al
callq 0x10b0
leaq 0x2c81(%rip), %rdi      # 0x4088
movb $0x0, %al
callq 0x10b0
leaq 0x2c96(%rip), %rdi      # 0x40ab
movb $0x0, %al
callq 0x10b0
leaq 0x2ca9(%rip), %rdi      # 0x40cc
movb $0x0, %al
callq 0x10b0
leaq 0x2cc5(%rip), %rdi      # 0x40f6
movb $0x0, %al
callq 0x10b0
leaq 0x2cd9(%rip), %rdi      # 0x4118
movb $0x0, %al
callq 0x10b0
leaq 0x2cdd(%rip), %rdi      # 0x412a
movb $0x0, %al
callq 0x10b0
leaq 0x2d0c(%rip), %rdi      # 0x4167
movb $0x0, %al
callq 0x10b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_init
gnuplot_ctrl * gnuplot_init(void)
{
    gnuplot_ctrl *  handle ;
    int i;

#ifndef WIN32
    if (getenv("DISPLAY") == NULL) {
        fprintf(stderr, "cannot find DISPLAY variable: is it set?\n") ;
    }
#endif // #ifndef WIN32


    /*
     * Structure initialization:
     */
    handle = (gnuplot_ctrl*)malloc(sizeof(gnuplot_ctrl)) ;
    handle->nplots = 0 ;
    gnuplot_setstyle(handle, "points") ;
    handle->ntmp = 0 ;

    handle->gnucmd = popen("gnuplot", "w") ;
    if (handle->gnucmd == NULL) {
        fprintf(stderr, "error starting gnuplot, is gnuplot or gnuplot.exe in your path?\n") ;
        free(handle) ;
        return NULL ;
    }

    for (i=0;i<GP_MAX_TMP_FILES; i++)
    {
        handle->tmp_filename_tbl[i] = NULL;
    }
    return handle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x1f05(%rip), %rdi      # 0x4424
callq 0x1030
cmpq $0x0, %rax
jne 0x2542
movq 0x3ac7(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x1ef1(%rip), %rsi      # 0x442c
movb $0x0, %al
callq 0x1110
movl $0x238, %edi            # imm = 0x238
callq 0x1130
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
leaq 0x1f6a(%rip), %rsi      # 0x44d0
callq 0x2610
movq -0x10(%rbp), %rax
movl $0x0, 0x230(%rax)
leaq 0x1ed6(%rip), %rdi      # 0x4456
leaq 0x1ed7(%rip), %rsi      # 0x445e
callq 0x1170
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x25cb
movq 0x3a51(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x1eaf(%rip), %rsi      # 0x4460
movb $0x0, %al
callq 0x1110
movq -0x10(%rbp), %rdi
callq 0x1040
movq $0x0, -0x8(%rbp)
jmp 0x25fc
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jge 0x25f4
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, 0x30(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x25d2
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_setstyle
void gnuplot_setstyle(gnuplot_ctrl * h, char * plot_style)
{
    if (strcmp(plot_style, "lines") &&
        strcmp(plot_style, "points") &&
        strcmp(plot_style, "linespoints") &&
        strcmp(plot_style, "impulses") &&
        strcmp(plot_style, "dots") &&
        strcmp(plot_style, "steps") &&
        strcmp(plot_style, "errorbars") &&
        strcmp(plot_style, "boxes") &&
        strcmp(plot_style, "boxerrorbars")) {
        fprintf(stderr, "warning: unknown requested style: using points\n") ;
        strcpy(h->pstyle, "points") ;
    } else {
        strcpy(h->pstyle, plot_style) ;
    }
    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1d8a(%rip), %rsi      # 0x43b5
callq 0x10f0
cmpl $0x0, %eax
je 0x271f
movq -0x10(%rbp), %rdi
leaq 0x1e8c(%rip), %rsi      # 0x44d0
callq 0x10f0
cmpl $0x0, %eax
je 0x271f
movq -0x10(%rbp), %rdi
leaq 0x1e6e(%rip), %rsi      # 0x44cb
callq 0x10f0
cmpl $0x0, %eax
je 0x271f
movq -0x10(%rbp), %rdi
leaq 0x1e61(%rip), %rsi      # 0x44d7
callq 0x10f0
cmpl $0x0, %eax
je 0x271f
movq -0x10(%rbp), %rdi
leaq 0x1e51(%rip), %rsi      # 0x44e0
callq 0x10f0
cmpl $0x0, %eax
je 0x271f
movq -0x10(%rbp), %rdi
leaq 0x1e3d(%rip), %rsi      # 0x44e5
callq 0x10f0
cmpl $0x0, %eax
je 0x271f
movq -0x10(%rbp), %rdi
leaq 0x1e37(%rip), %rsi      # 0x44f4
callq 0x10f0
cmpl $0x0, %eax
je 0x271f
movq -0x10(%rbp), %rdi
leaq 0x1e19(%rip), %rsi      # 0x44eb
callq 0x10f0
cmpl $0x0, %eax
je 0x271f
movq -0x10(%rbp), %rdi
leaq 0x1e0a(%rip), %rsi      # 0x44f1
callq 0x10f0
cmpl $0x0, %eax
je 0x271f
movq 0x3900(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x1dfc(%rip), %rsi      # 0x44fe
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
addq $0xc, %rdi
leaq 0x1db8(%rip), %rsi      # 0x44d0
callq 0x1070
jmp 0x2730
movq -0x8(%rbp), %rdi
addq $0xc, %rdi
movq -0x10(%rbp), %rsi
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_close
void gnuplot_close(gnuplot_ctrl * handle)
{
    int     i ;

    if (pclose(handle->gnucmd) == -1) {
        fprintf(stderr, "problem closing communication to gnuplot\n") ;
        return ;
    }
    if (handle->ntmp) {
        for (i=0 ; i<handle->ntmp ; i++) {
            remove(handle->tmp_filename_tbl[i]) ;
            free(handle->tmp_filename_tbl[i]);
            handle->tmp_filename_tbl[i] = NULL;

        }
    }
    free(handle) ;
    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x10c0
cmpl $-0x1, %eax
jne 0x2777
movq 0x3894(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x1d33(%rip), %rsi      # 0x44a1
movb $0x0, %al
callq 0x1110
jmp 0x27e5
movq -0x8(%rbp), %rax
cmpl $0x0, 0x230(%rax)
je 0x27dc
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x230(%rcx), %eax
jge 0x27da
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rdi
callq 0x1060
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, 0x30(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x278b
jmp 0x27dc
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_cmd
void gnuplot_cmd(gnuplot_ctrl *  handle, char const *  cmd, ...)
{
    va_list ap ;

    va_start(ap, cmd);
    vfprintf(handle->gnucmd, cmd, ap);
    va_end(ap);

    fputs("\n", handle->gnucmd) ;
    fflush(handle->gnucmd) ;
    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x2828
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)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11a0
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x17ea(%rip), %rdi      # 0x4079
callq 0x10e0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1140
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_resetplot
void gnuplot_resetplot(gnuplot_ctrl * h)
{
    int     i ;
    if (h->ntmp) {
        for (i=0 ; i<h->ntmp ; i++) {
            remove(h->tmp_filename_tbl[i]) ;
            free(h->tmp_filename_tbl[i]);
            h->tmp_filename_tbl[i] = NULL;

        }
    }
    h->ntmp = 0 ;
    h->nplots = 0 ;
    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x230(%rax)
je 0x2981
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x230(%rcx), %eax
jge 0x297f
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rdi
callq 0x1060
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, 0x30(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2930
jmp 0x2981
movq -0x8(%rbp), %rax
movl $0x0, 0x230(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_plot_x
void gnuplot_plot_x(
    gnuplot_ctrl    *   handle,
    double          *   d,
    int                 n,
    char            *   title
)
{
    int     i ;
    FILE*   tmpfd ;
    char const * tmpfname;

    if (handle==NULL || d==NULL || (n<1)) return ;

    /* Open temporary file for output   */
    tmpfname = gnuplot_tmpfile(handle);
    tmpfd = fopen(tmpfname, "w");

    if (tmpfd == NULL) {
        fprintf(stderr,"cannot create temporary file: exiting plot") ;
        return ;
    }

    /* Write data to this file  */
    for (i=0 ; i<n ; i++) {
      fprintf(tmpfd, "%.18e\n", d[i]);
    }
    fclose(tmpfd) ;

    gnuplot_plot_atmpfile(handle,tmpfname,title);
    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x29cb
cmpq $0x0, -0x10(%rbp)
je 0x29cb
cmpl $0x1, -0x14(%rbp)
jge 0x29d0
jmp 0x2a65
movq -0x8(%rbp), %rdi
callq 0x2a70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x1a76(%rip), %rsi      # 0x445e
callq 0x1180
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2a12
movq 0x35f9(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x1b45(%rip), %rsi      # 0x454e
movb $0x0, %al
callq 0x1110
jmp 0x2a65
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2a4b
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x1bb8(%rip), %rsi      # 0x45f1
movb $0x1, %al
callq 0x1110
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2a19
movq -0x30(%rbp), %rdi
callq 0x1090
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2b90
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_tmpfile
char const * gnuplot_tmpfile(gnuplot_ctrl * handle)
{
    static char const * tmp_filename_template = "gnuplot_tmpdatafile_XXXXXX";
    char *              tmp_filename = NULL;
    int                 tmp_filelen = strlen(tmp_filename_template);

#ifndef WIN32
    int                 unx_fd;
#endif // #ifndef WIN32

    assert(handle->tmp_filename_tbl[handle->ntmp] == NULL);

    /* Open one more temporary file? */
    if (handle->ntmp == GP_MAX_TMP_FILES - 1) {
        fprintf(stderr,
                "maximum # of temporary files reached (%d): cannot open more",
                GP_MAX_TMP_FILES) ;
        return NULL;
    }

    tmp_filename = (char*) malloc(tmp_filelen+1);
    if (tmp_filename == NULL)
    {
        return NULL;
    }
    strcpy(tmp_filename, tmp_filename_template);

#ifdef WIN32
    if (_mktemp(tmp_filename) == NULL)
    {
        return NULL;
    }
#else // #ifdef WIN32
    unx_fd = mkstemp(tmp_filename);
    if (unx_fd == -1)
    {
        return NULL;
    }
    //close(unx_fd);

#endif // #ifdef WIN32

    handle->tmp_filename_tbl[handle->ntmp] = tmp_filename;
    handle->ntmp ++;
    return tmp_filename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x366d(%rip), %rdi      # 0x60f8
callq 0x10a0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x230(%rcx), %rcx
cmpq $0x0, 0x30(%rax,%rcx,8)
jne 0x2aac
jmp 0x2acb
leaq 0x1b78(%rip), %rdi      # 0x462b
leaq 0x1ba0(%rip), %rsi      # 0x465a
movl $0x29c, %edx            # imm = 0x29C
leaq 0x1ba4(%rip), %rcx      # 0x466a
callq 0x10d0
movq -0x10(%rbp), %rax
cmpl $0x3f, 0x230(%rax)
jne 0x2b02
movq 0x3519(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x1bad(%rip), %rsi      # 0x4696
movl $0x40, %edx
movb $0x0, %al
callq 0x1110
movq $0x0, -0x8(%rbp)
jmp 0x2b84
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2b25
movq $0x0, -0x8(%rbp)
jmp 0x2b84
movq -0x18(%rbp), %rdi
movq 0x35c8(%rip), %rsi      # 0x60f8
callq 0x1070
movq -0x18(%rbp), %rdi
callq 0x1150
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x2b51
movq $0x0, -0x8(%rbp)
jmp 0x2b84
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x230(%rcx), %rcx
movq %rdx, 0x30(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x230(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x230(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_plot_atmpfile
void gnuplot_plot_atmpfile(gnuplot_ctrl * handle, char const* tmp_filename, char const* title)
{
    char const *    cmd    = (handle->nplots > 0) ? "replot" : "plot";
    title                  = (title == NULL)      ? "(none)" : title;
    gnuplot_cmd(handle, "%s \"%s\" title \"%s\" with %s", cmd, tmp_filename,
                  title, handle->pstyle) ;
    handle->nplots++ ;
    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x19c2(%rip), %rax      # 0x4574
leaq 0x1857(%rip), %rcx      # 0x4410
cmpl $0x0, %edx
cmovgq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2bd8
leaq 0x19cd(%rip), %rax      # 0x459f
movq %rax, -0x28(%rbp)
jmp 0x2be0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x8(%rbp), %r9
addq $0xc, %r9
leaq 0x1acb(%rip), %rsi      # 0x46d2
movb $0x0, %al
callq 0x27f0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_plot_xy
void gnuplot_plot_xy(
    gnuplot_ctrl    *   handle,
    double          *   x,
    double          *   y,
    int                 n,
    char            *   title
)
{
    int     i ;
    FILE*   tmpfd ;
    char const * tmpfname;

    if (handle==NULL || x==NULL || y==NULL || (n<1)) return ;

    /* Open temporary file for output   */
    tmpfname = gnuplot_tmpfile(handle);
    tmpfd = fopen(tmpfname, "w");

    if (tmpfd == NULL) {
        fprintf(stderr,"cannot create temporary file: exiting plot") ;
        return ;
    }

    /* Write data to this file  */
    for (i=0 ; i<n; i++) {
        fprintf(tmpfd, "%.18e %.18e\n", x[i], y[i]) ;
    }
    fclose(tmpfd) ;

    gnuplot_plot_atmpfile(handle,tmpfname,title);
    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2c66
cmpq $0x0, -0x10(%rbp)
je 0x2c66
cmpq $0x0, -0x18(%rbp)
je 0x2c66
cmpl $0x1, -0x1c(%rbp)
jge 0x2c6b
jmp 0x2d0d
movq -0x8(%rbp), %rdi
callq 0x2a70
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
leaq 0x17db(%rip), %rsi      # 0x445e
callq 0x1180
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2cad
movq 0x335e(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x18aa(%rip), %rsi      # 0x454e
movb $0x0, %al
callq 0x1110
jmp 0x2d0d
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2cf3
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
leaq 0x1898(%rip), %rsi      # 0x4579
movb $0x2, %al
callq 0x1110
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2cb4
movq -0x38(%rbp), %rdi
callq 0x1090
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2b90
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_plot_once
void gnuplot_plot_once(
  char    *   title,
  char    *   style,
  char    *   label_x,
  char    *   label_y,
  double  *   x,
  double  *   y,
  int         n
)
{
  gnuplot_ctrl    *   handle ;

  if (x==NULL || n<1) return ;

  if ((handle = gnuplot_init()) == NULL) return ;
  if (style!=NULL) {
      gnuplot_setstyle(handle, style);
  } else {
      gnuplot_setstyle(handle, "lines");
  }
  if (label_x!=NULL) {
      gnuplot_set_xlabel(handle, label_x);
  } else {
      gnuplot_set_xlabel(handle, "X");
  }
  if (label_y!=NULL) {
      gnuplot_set_ylabel(handle, label_y);
  } else {
      gnuplot_set_ylabel(handle, "Y");
  }
  if (y==NULL) {
      gnuplot_plot_x(handle, x, n, title);
  } else {
      gnuplot_plot_xy(handle, x, y, n, title);
  }
  printf("press ENTER to continue\n");
  while (getchar()!='\n') {}
  gnuplot_close(handle);
  return ;
}

// 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)
cmpq $0x0, -0x28(%rbp)
je 0x2d50
cmpl $0x1, 0x10(%rbp)
jge 0x2d55
jmp 0x2e33
callq 0x2510
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x2d69
jmp 0x2e33
cmpq $0x0, -0x10(%rbp)
je 0x2d7f
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2610
jmp 0x2d8f
movq -0x38(%rbp), %rdi
leaq 0x162b(%rip), %rsi      # 0x43b5
callq 0x2610
cmpq $0x0, -0x18(%rbp)
je 0x2da5
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x28b0
jmp 0x2db5
movq -0x38(%rbp), %rdi
leaq 0x1879(%rip), %rsi      # 0x4629
callq 0x28b0
cmpq $0x0, -0x20(%rbp)
je 0x2dcb
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x28e0
jmp 0x2ddb
movq -0x38(%rbp), %rdi
leaq 0x1654(%rip), %rsi      # 0x442a
callq 0x28e0
cmpq $0x0, -0x30(%rbp)
jne 0x2df8
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl 0x10(%rbp), %edx
movq -0x8(%rbp), %rcx
callq 0x29a0
jmp 0x2e10
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl 0x10(%rbp), %ecx
movq -0x8(%rbp), %r8
callq 0x2c30
leaq 0x176f(%rip), %rdi      # 0x4586
movb $0x0, %al
callq 0x10b0
callq 0x1100
cmpl $0xa, %eax
je 0x2e2a
jmp 0x2e1e
movq -0x38(%rbp), %rdi
callq 0x2740
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_plot_slope
void gnuplot_plot_slope(
    gnuplot_ctrl    *   handle,
    double              a,
    double              b,
    char            *   title
)
{
    char const *    cmd    = (handle->nplots > 0) ? "replot" : "plot";
    title                  = (title == NULL)      ? "(none)" : title;

    gnuplot_cmd(handle, "%s %.18e * x + %.18e title \"%s\" with %s",
                  cmd, a, b, title, handle->pstyle) ;

    handle->nplots++ ;
    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x170c(%rip), %rax      # 0x4574
leaq 0x15a1(%rip), %rcx      # 0x4410
cmpl $0x0, %edx
cmovgq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2e8e
leaq 0x1717(%rip), %rax      # 0x459f
movq %rax, -0x30(%rbp)
jmp 0x2e96
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %r8
addq $0xc, %r8
leaq 0x16e3(%rip), %rsi      # 0x45a6
movb $0x2, %al
callq 0x27f0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_plot_equation
void gnuplot_plot_equation(
    gnuplot_ctrl    *   h,
    char            *   equation,
    char            *   title
)
{
    char const *    cmd    = (h->nplots > 0) ? "replot" : "plot";
    title                  = (title == NULL)      ? "(none)" : title;

    gnuplot_cmd(h, "%s %s title \"%s\" with %s",
                  cmd, equation, title, h->pstyle) ;
    h->nplots++ ;
    return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x1672(%rip), %rax      # 0x4574
leaq 0x1507(%rip), %rcx      # 0x4410
cmpl $0x0, %edx
cmovgq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2f28
leaq 0x167d(%rip), %rax      # 0x459f
movq %rax, -0x28(%rbp)
jmp 0x2f30
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x8(%rbp), %r9
addq $0xc, %r9
leaq 0x1677(%rip), %rsi      # 0x45ce
movb $0x0, %al
callq 0x27f0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_write_x_csv
int gnuplot_write_x_csv(
    char const * fileName,
    double const * d,
    int n,
    char const * title)
{
    int     i;
    FILE*   fileHandle;

    if (fileName==NULL || d==NULL || (n<1))
    {
        return -1;
    }

    fileHandle = fopen(fileName, "w");

    if (fileHandle == NULL)
    {
        return -1;
    }

    // Write Comment.
    if (title != NULL)
    {
        fprintf(fileHandle, "# %s\n", title) ;
    }

    /* Write data to this file  */
    for (i=0 ; i<n; i++)
    {
        fprintf(fileHandle, "%d, %.18e\n", i, d[i]) ;
    }

    fclose(fileHandle) ;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2fab
cmpq $0x0, -0x18(%rbp)
je 0x2fab
cmpl $0x1, -0x1c(%rbp)
jge 0x2fb7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3044
movq -0x10(%rbp), %rdi
leaq 0x149c(%rip), %rsi      # 0x445e
callq 0x1180
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2fdb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3044
cmpq $0x0, -0x28(%rbp)
je 0x2ff8
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x15f6(%rip), %rsi      # 0x45e7
movb $0x0, %al
callq 0x1110
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3034
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x15cb(%rip), %rsi      # 0x45ed
movb $0x1, %al
callq 0x1110
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fff
movq -0x38(%rbp), %rdi
callq 0x1090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_write_xy_csv
int gnuplot_write_xy_csv(
    char const *        fileName,
    double const    *   x,
    double const    *   y,
    int                 n,
    char const      *   title)
{
    int     i ;
    FILE*   fileHandle;

    if (fileName==NULL || x==NULL || y==NULL || (n<1))
    {
        return -1;
    }

    fileHandle = fopen(fileName, "w");

    if (fileHandle == NULL)
    {
        return -1;
    }

    // Write Comment.
    if (title != NULL)
    {
        fprintf(fileHandle, "# %s\n", title) ;
    }

    /* Write data to this file  */
    for (i=0 ; i<n; i++)
    {
        fprintf(fileHandle, "%.18e, %.18e\n", x[i], y[i]) ;
    }

    fclose(fileHandle) ;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3086
cmpq $0x0, -0x18(%rbp)
je 0x3086
cmpq $0x0, -0x20(%rbp)
je 0x3086
cmpl $0x1, -0x24(%rbp)
jge 0x3092
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3129
movq -0x10(%rbp), %rdi
leaq 0x13c1(%rip), %rsi      # 0x445e
callq 0x1180
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x30b6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3129
cmpq $0x0, -0x30(%rbp)
je 0x30d3
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x151b(%rip), %rsi      # 0x45e7
movb $0x0, %al
callq 0x1110
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x3119
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
leaq 0x14f1(%rip), %rsi      # 0x45f8
movb $0x2, %al
callq 0x1110
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x30da
movq -0x40(%rbp), %rdi
callq 0x1090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohamedamjad[P]UBLOXlib/src/gnuplot_i.c
// Function: gnuplot_write_multi_csv
int gnuplot_write_multi_csv(
    char const *        fileName,
    double const    **  xListPtr,
    int                 n,
    int                 numColumns,
    char const      *   title)
{
    int     i;
    int     j;
    FILE*   fileHandle;

    if (fileName==NULL || xListPtr==NULL || (n<1) || numColumns <1)
    {
        return -1;
    }

    for (j=0;j<numColumns;j++)
    {
        if (xListPtr[j] == NULL)
        {
            return -1;
        }
    }

    fileHandle = fopen(fileName, "w");

    if (fileHandle == NULL)
    {
        return -1;
    }

    // Write Comment.
    if (title != NULL)
    {
        fprintf(fileHandle, "# %s\n", title) ;
    }

    /* Write data to this file  */
    for (i=0 ; i<n; i++)
    {
        fprintf(fileHandle, "%d, %.18e", i, xListPtr[0][i]) ;
        for (j=1;j<numColumns;j++)
        {
            fprintf(fileHandle, ", %.18e", xListPtr[j][i]) ;
        }
        fprintf(fileHandle, "\n");
    }

    fclose(fileHandle) ;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3174
cmpq $0x0, -0x18(%rbp)
je 0x3174
cmpl $0x1, -0x1c(%rbp)
jl 0x3174
cmpl $0x1, -0x20(%rbp)
jge 0x3180
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x32a4
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x31b7
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x31aa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x32a4
jmp 0x31ac
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3187
movq -0x10(%rbp), %rdi
leaq 0x129c(%rip), %rsi      # 0x445e
callq 0x1180
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x31de
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x32a4
cmpq $0x0, -0x28(%rbp)
je 0x31fb
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x13f3(%rip), %rsi      # 0x45e7
movb $0x0, %al
callq 0x1110
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3294
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x13da(%rip), %rsi      # 0x4606
movb $0x1, %al
callq 0x1110
movl $0x1, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x3274
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x13a6(%rip), %rsi      # 0x4608
movb $0x1, %al
callq 0x1110
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x323a
movq -0x38(%rbp), %rdi
leaq 0xdfa(%rip), %rsi       # 0x4079
movb $0x0, %al
callq 0x1110
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3202
movq -0x38(%rbp), %rdi
callq 0x1090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test-bcf-translate.c
// Function: error
void HTS_FORMAT(HTS_PRINTF_FMT, 1, 2) error(const char *format, ...)
{
    va_list ap;
    va_start(ap, format);
    vfprintf(stderr, format, ap);
    va_end(ap);
    exit(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x5af5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x11f491(%rip), %rax    # 0x124fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x4680
leaq -0x20(%rbp), %rax
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x45d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hrec_destroy
void bcf_hrec_destroy(bcf_hrec_t *hrec)
{
    if (!hrec) return;
    free(hrec->key);
    if ( hrec->value ) free(hrec->value);
    int i;
    for (i=0; i<hrec->nkeys; i++)
    {
        free(hrec->keys[i]);
        free(hrec->vals[i]);
    }
    free(hrec->keys);
    free(hrec->vals);
    free(hrec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3b058
jmp 0x3b0e8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3b07d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x45a0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x3b0c5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x45a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3b084
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x45a0
movq -0x8(%rbp), %rdi
callq 0x45a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hrec_debug
void bcf_hrec_debug(FILE *fp, bcf_hrec_t *hrec)
{
    fprintf(fp, "key=[%s] value=[%s]", hrec->key, hrec->value?hrec->value:"");
    int i;
    for (i=0; i<hrec->nkeys; i++)
        fprintf(fp, "\t[%s]=[%s]", hrec->keys[i],hrec->vals[i]);
    fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3b3dd
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x3b3ea
leaq 0xc8646(%rip), %rax     # 0x103a2a
movq %rax, -0x30(%rbp)
jmp 0x3b3ea
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rcx
leaq 0xcc213(%rip), %rsi     # 0x107610
movb $0x0, %al
callq 0x46f0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x3b454
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0xcc1e2(%rip), %rsi     # 0x107624
movb $0x0, %al
callq 0x46f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3b40b
movq -0x8(%rbp), %rdi
leaq 0xc9654(%rip), %rsi     # 0x104ab3
movb $0x0, %al
callq 0x46f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_header_debug
void bcf_header_debug(bcf_hdr_t *hdr)
{
    int i, j;
    for (i=0; i<hdr->nhrec; i++)
    {
        if ( !hdr->hrec[i]->value )
        {
            fprintf(stderr, "##%s=<", hdr->hrec[i]->key);
            fprintf(stderr,"%s=%s", hdr->hrec[i]->keys[0], hdr->hrec[i]->vals[0]);
            for (j=1; j<hdr->hrec[i]->nkeys; j++)
                fprintf(stderr,",%s=%s", hdr->hrec[i]->keys[j], hdr->hrec[i]->vals[j]);
            fprintf(stderr,">\n");
        }
        else
            fprintf(stderr,"##%s=%s\n", hdr->hrec[i]->key,hdr->hrec[i]->value);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jge 0x3b604
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3b5b4
movq 0xe9b23(%rip), %rax     # 0x124fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdx
leaq 0xcc15c(%rip), %rsi     # 0x10762f
movb $0x0, %al
callq 0x46f0
movq 0xe9af7(%rip), %rax     # 0x124fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
leaq 0xcc2bb(%rip), %rsi     # 0x1077d4
movb $0x0, %al
callq 0x46f0
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl 0x18(%rcx), %eax
jge 0x3b59a
movq 0xe9a92(%rip), %rax     # 0x124fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0xcc0ae(%rip), %rsi     # 0x107636
movb $0x0, %al
callq 0x46f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3b527
movq 0xe9a37(%rip), %rax     # 0x124fd8
movq (%rax), %rdi
leaq 0xcc092(%rip), %rsi     # 0x10763d
movb $0x0, %al
callq 0x46f0
jmp 0x3b5f4
movq 0xe9a1d(%rip), %rax     # 0x124fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rcx
leaq 0xcc053(%rip), %rsi     # 0x107640
movb $0x0, %al
callq 0x46f0
jmp 0x3b5f6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3b483
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: bcf_hrec_add_key
int bcf_hrec_add_key(bcf_hrec_t *hrec, const char *str, size_t len)
{
    char **tmp;
    size_t n = hrec->nkeys + 1;
    assert(len > 0 && len < SIZE_MAX);
    tmp = realloc(hrec->keys, sizeof(char*)*n);
    if (!tmp) return -1;
    hrec->keys = tmp;
    tmp = realloc(hrec->vals, sizeof(char*)*n);
    if (!tmp) return -1;
    hrec->vals = tmp;

    hrec->keys[hrec->nkeys] = (char*) malloc((len+1)*sizeof(char));
    if (!hrec->keys[hrec->nkeys]) return -1;
    memcpy(hrec->keys[hrec->nkeys],str,len);
    hrec->keys[hrec->nkeys][len] = 0;
    hrec->vals[hrec->nkeys] = NULL;
    hrec->nkeys = n;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
cltq
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x3b644
cmpq $-0x1, -0x20(%rbp)
jae 0x3b644
jmp 0x3b663
leaq 0xcbffe(%rip), %rdi     # 0x107649
leaq 0xcc011(%rip), %rsi     # 0x107663
movl $0x1a2, %edx            # imm = 0x1A2
leaq 0xcc00b(%rip), %rcx     # 0x107669
callq 0x42d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x30(%rbp), %rsi
shlq $0x3, %rsi
callq 0x4840
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3b68f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b784
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x30(%rbp), %rsi
shlq $0x3, %rsi
callq 0x4840
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3b6c7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b784
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x4670
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x3b71b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b784
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x43b0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)