LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::read_bytes(scdc_transport_connection_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, long long)
static bool read_bytes(scdc_transport_connection_t *transport_connection_, string *s, scdcint_t nbytes)
    {
      scdc_data *incoming = transport_connection_->get_incoming();
      bool ret = true;

      (*s).clear();

      while (ret)
      {
        const char *src = incoming->get_read_pos_buf();
        scdcint_t src_size = incoming->get_read_pos_buf_size();

        scdcint_t n = min(nbytes, src_size);

        *s += string(src, n);

        incoming->inc_read_pos(n);
        nbytes -= n;

        if (nbytes <= 0) break;

        ret = incoming->do_next();
      }

      return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa3650
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc8f0
testb $0x1, -0x21(%rbp)
je 0xa3f30
movq -0x20(%rbp), %rdi
callq 0x2ebe0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ec00
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2b080
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xcbc0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
leaq -0x60(%rbp), %rdi
callq 0xc7a0
jmp 0xa3ea9
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xc8a0
jmp 0xa3eb8
leaq -0x60(%rbp), %rdi
callq 0xc3e0
leaq -0x61(%rbp), %rdi
callq 0xc730
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2ec60
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jg 0xa3f1d
jmp 0xa3f30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xa3f12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xc3e0
leaq -0x61(%rbp), %rdi
callq 0xc730
jmp 0xa3f3e
movq -0x20(%rbp), %rdi
callq 0x2ec20
andb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0xa3e31
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xcba0
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/common/data.cc
// Function: scdc_data::compact()
void scdc_data::compact()
{
  if (read_pos <= 0) return;

  SCDC_TRACE("compact: " << write_pos - read_pos << " bytes at offset " << read_pos);

  if (read_pos < write_pos) memmove(buf, buf + read_pos, write_pos - read_pos);

  write_pos -= read_pos;
  read_pos = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x28(%rax)
jg 0xa446d
jmp 0xa44b7
jmp 0xa446f
jmp 0xa4471
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rax
cmpq 0x20(%rcx), %rax
jge 0xa449c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rax), %rsi
addq 0x28(%rax), %rsi
movq 0x20(%rax), %rdx
subq 0x28(%rax), %rdx
callq 0xcb20
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
movq 0x20(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Andrea-Guerrieri[P]LEOSoC/LEOSoC/LEOSoC.cpp
// Function: interrupt_thread(void*)
void* interrupt_thread( void *i )
{
    
    uint32_t interrupts_pendings;
    unsigned char indx;


  while ( app_run )
    {
      usleep ( 1 );
      //printf ( "Checking interrupts \n\r" );

      interrupts_pendings = leosoc_read_reg ( AIC_INTERRUPTS_REG_0 );

      //interrupts_pendings = 0x01; //
      
      if ( interrupts_pendings )
        {
          for ( indx = 0; indx < 4; indx++ )
            {
              if ( interrupts_pendings & ( 1 << ( indx - 1 ) ) )
                {
                    pl.aaw[indx].pr.status = STATUS_ENDED;
                    printf ( "thread %d terminate \n\r", indx );
                    interrupts_pendings = 0x00; //

                }
            }
        }

    }
    
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpb $0x0, 0x1f0f9d(%rip)    # 0x5f5590
je 0x404688
movl $0x1, %edi
callq 0x534870
movl $0x8, %edi
callq 0x404690
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x404683
movb $0x0, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
cmpl $0x4, %eax
jge 0x404681
movl -0xc(%rbp), %eax
movzbl -0xd(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x404675
movzbl -0xd(%rbp), %eax
movl %eax, %ecx
leaq 0x1f0f4e(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x4, 0x1c(%rax)
movzbl -0xd(%rbp), %esi
leaq 0x18199d(%rip), %rdi    # 0x586004
movb $0x0, %al
callq 0x4cc510
movl $0x0, -0xc(%rbp)
jmp 0x404677
movb -0xd(%rbp), %al
addb $0x1, %al
movb %al, -0xd(%rbp)
jmp 0x40461a
jmp 0x404683
jmp 0x4045ec
ud2
nopw (%rax,%rax)
// File: Andrea-Guerrieri[P]LEOSoC/LEOSoC/LEOSoC.cpp
// Function: timer_thread(void*)
void* timer_thread( void *id )
{

    uint32_t indx; 
    
    while ( app_run )
    {
        for ( indx = 0; indx < PR_REGIONS; indx++ )
        {
            if ( pl.aaw[indx].pr.status == STATUS_PROGRAMMED )
            {
                pl.aaw[indx].pr.timeout--;
                if ( ( pl.aaw[indx].pr.timeout ) )
                {
                    if ( pl.aaw[indx].pr.status == STATUS_ENDED )
                    {
                        printf ( "thread %d counting \n\r", indx );
                        //break;
                    }
                }
                else
                {
                    pl.aaw[indx].pr.status = STATUS_ENDED;
                    printf ( "thread %d timeout exit\n\r", indx );
                }

            }
            
        }
        usleep ( 1 );
    }    

    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpb $0x0, 0x1f0ecd(%rip)    # 0x5f5590
je 0x4047b8
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jae 0x4047a9
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1f0eb2(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, 0x1c(%rax)
jne 0x404799
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1f0e91(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0x28(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x28(%rax)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1f0e71(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x28(%rax)
je 0x404768
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1f0e54(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x4, 0x1c(%rax)
jne 0x404766
movl -0xc(%rbp), %esi
leaq 0x1818bc(%rip), %rdi    # 0x58601b
movb $0x0, %al
callq 0x4cc510
jmp 0x404797
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1f0e24(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x4, 0x1c(%rax)
movl -0xc(%rbp), %esi
leaq 0x1818a1(%rip), %rdi    # 0x586031
movb $0x0, %al
callq 0x4cc510
jmp 0x404799
jmp 0x40479b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4046d0
movl $0x1, %edi
callq 0x534870
jmp 0x4046bc
ud2
nopw (%rax,%rax)
// File: Andrea-Guerrieri[P]LEOSoC/LEOSoC/LEOSoC.cpp
// Function: leosoc_init(int)
int leosoc_init ( int id )
{

    printf ( "LEOSoC start\n\r" );

    for ( int indx = 0; indx < PR_REGIONS; indx++ )
    {
            pl.aaw[indx].pr.timeout = 5;
    }

    if ( pmu_detect_platform () )
    {
        fpi_program_full ( id );
        pthread_create( &interrupt , NULL, interrupt_thread, ( void * ) NULL );
        pthread_create( &timer[id] , NULL, timer_thread, ( void * ) id );


        app_run = TRUE;
    }
    else
    {
        app_run = FALSE;
        leosoc_end ();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x181858(%rip), %rdi    # 0x58604a
movb $0x0, %al
callq 0x4cc510
movl $0x0, -0x8(%rbp)
cmpl $0x8, -0x8(%rbp)
jge 0x40482e
movslq -0x8(%rbp), %rcx
leaq 0x1f0d87(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x5, 0x28(%rax)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x404800
callq 0x404ae0
cmpb $0x0, %al
je 0x40488b
movl -0x4(%rbp), %eax
movzbl %al, %edi
callq 0x404cd0
leaq 0x1f146f(%rip), %rdi    # 0x5f5cb8
xorl %eax, %eax
movl %eax, %ecx
leaq -0x274(%rip), %rdx      # 0x4045e0
movq %rcx, %rsi
callq 0x4de770
movslq -0x4(%rbp), %rax
leaq 0x1f1459(%rip), %rdi    # 0x5f5cc0
shlq $0x3, %rax
addq %rax, %rdi
movslq -0x4(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq -0x1cd(%rip), %rdx      # 0x4046b0
callq 0x4de770
movb $0x1, 0x1f0d07(%rip)    # 0x5f5590
jmp 0x404897
movb $0x0, 0x1f0cfe(%rip)    # 0x5f5590
callq 0x4048a0
ud2
nopl (%rax)
// File: Andrea-Guerrieri[P]LEOSoC/LEOSoC/LEOSoC.cpp
// Function: leosoc_create(int, void*, void*)
int leosoc_create ( int id, void *input_data, void *output_data )
{

  unsigned int indx;
  input_data_p = input_data;	//copy the address into a local pointer
  output_data_p = output_data;


  for ( indx = 0; indx < PR_REGIONS; indx++ )
    {
      if ( pl.aaw[indx].pr.status != STATUS_RUNNING && pl.aaw[indx].pr.status != STATUS_PROGRAMMED )
        {

          fpi_program_partial ( id, indx );

          pl.aaw[indx].pr.id = id;
          pl.aaw[indx].pr.module = id;
          pl.aaw[indx].pr.status = STATUS_PROGRAMMED;


          //User-Code
          //setup_start_accelerator (  ); //

          //pl.aaw[indx].pr.status = STATUS_RUNNING; //Test purpose

          break;
        }
    }

  printf ( "hw thread id %d created \n\r", id );


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x1f1402(%rip)    # 0x5f5ce0
movq -0x18(%rbp), %rax
movq %rax, 0x1f13ff(%rip)    # 0x5f5ce8
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jae 0x4049b5
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x1f0c92(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x3, 0x1c(%rax)
je 0x4049a5
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x1f0c71(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, 0x1c(%rax)
je 0x4049a5
movl -0x4(%rbp), %eax
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %edi
movzbl %al, %esi
callq 0x404d20
movl -0x4(%rbp), %ecx
movl -0x1c(%rbp), %eax
movl %eax, %edx
leaq 0x1f0c3e(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x14(%rax)
movl -0x4(%rbp), %ecx
movl -0x1c(%rbp), %eax
movl %eax, %edx
leaq 0x1f0c21(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x1f0c07(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x2, 0x1c(%rax)
jmp 0x4049b5
jmp 0x4049a7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4048f0
movl -0x4(%rbp), %esi
leaq 0x18169a(%rip), %rdi    # 0x586059
movb $0x0, %al
callq 0x4cc510
ud2
nopl (%rax,%rax)
// File: Andrea-Guerrieri[P]LEOSoC/LEOSoC/LEOSoC.cpp
// Function: leosoc_join(int, int)
int leosoc_join ( int id, int timeout )
{
    printf ( "waiting for hw thread id %d \n\r", id );

  
    pl.aaw[id].pr.timeout = timeout*100000;

    while ( pl.aaw[id].pr.status != STATUS_ENDED )
    {
        usleep (1);
    }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %esi
leaq 0x18168c(%rip), %rdi    # 0x586074
movb $0x0, %al
callq 0x4cc510
imull $0x186a0, -0x8(%rbp), %ecx # imm = 0x186A0
movslq -0x4(%rbp), %rdx
leaq 0x1f0b97(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x28(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x1f0b7e(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x4, 0x1c(%rax)
je 0x404a37
movl $0x1, %edi
callq 0x534870
jmp 0x404a0f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Andrea-Guerrieri[P]LEOSoC/LEOSoC/LEOSoC.cpp
// Function: leosoc_cancel(int)
int leosoc_cancel ( int id )
{
  uint8_t indx;

  for ( indx = 0; indx < PR_REGIONS; indx++ )
    {
      if ( pl.aaw[indx].pr.id == id )
        {

          pl.aaw[indx].pr.status = STATUS_ENDED;

          break;
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x0, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
cmpl $0x8, %eax
jge 0x404aa1
movzbl -0x5(%rbp), %eax
movl %eax, %ecx
leaq 0x1f0b37(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x404a95
movzbl -0x5(%rbp), %eax
movl %eax, %ecx
leaq 0x1f0b17(%rip), %rax    # 0x5f5598
addq $0x8, %rax
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x4, 0x1c(%rax)
jmp 0x404aa1
jmp 0x404a97
movb -0x5(%rbp), %al
addb $0x1, %al
movb %al, -0x5(%rbp)
jmp 0x404a4b
ud2
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Andrea-Guerrieri[P]LEOSoC/LEOSoC/pmu.cpp
// Function: pmu_detect_platform()
uint8_t pmu_detect_platform ( )
{
    run_env = ENV_NONE;
    uint32_t indx;

    for ( indx = 0; indx < PLATFORM_MAX; indx++ ) 
    {
        if ( ! ( CHECK_FPGA ( fpga_prog_dev[indx] ) ) ) 
        {
            run_env = indx;
            break;
        }

    }

    switch ( run_env ) 
    {
        case ENV_XILINX:
            printf ( "Xilinx Running Environment recognized\n\r" );
            break;

        case ENV_ALTERA:
            printf ( "Altera Running Environment recognized\n\r" );
            break;

        default:
            printf ( "No FPGA Environment recognized\n\r" );
            return FALSE;

            break;
    }

    return TRUE;


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x2, 0x1f1201(%rip)    # 0x5f5cf0
movl $0x0, -0x8(%rbp)
cmpl $0x2, -0x8(%rbp)
jae 0x404b27
leaq 0x1a1b07(%rip), %rdi    # 0x5a660a
movb $0x0, %al
callq 0x4cc510
cmpl $0x0, %eax
jne 0x404b1a
movl -0x8(%rbp), %eax
movb %al, 0x1f11d8(%rip)     # 0x5f5cf0
jmp 0x404b27
jmp 0x404b1c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x404af6
movzbl 0x1f11c2(%rip), %eax    # 0x5f5cf0
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x404b41
jmp 0x404b37
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x404b51
jmp 0x404b61
leaq 0x181560(%rip), %rdi    # 0x5860a8
movb $0x0, %al
callq 0x4cc510
jmp 0x404b75
leaq 0x181578(%rip), %rdi    # 0x5860d0
movb $0x0, %al
callq 0x4cc510
jmp 0x404b75
leaq 0x181590(%rip), %rdi    # 0x5860f8
movb $0x0, %al
callq 0x4cc510
movb $0x0, -0x1(%rbp)
jmp 0x404b79
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Andrea-Guerrieri[P]LEOSoC/LEOSoC/fpga_if.cpp
// Function: fpi_program_full(unsigned char)
uint32_t fpi_program_full ( unsigned char type )
{
    long long start_time, end_time;
    uint32_t elapsed_time;
    start_time = current_timestamp();

    DEBUG_MODULE ( printf ( "%s\n\r", fpga_program_cmd[run_env] ) );
    if ( ! ( PROGRAM_FPGA ( fpga_program_cmd[run_env] ) ) ) 
    {
        DEBUG_MODULE ( printf ( " [DEBUG_MODULE] DFR ok \n\r" ) );
    } 
    else 
    {
        DEBUG_MODULE ( printf ( "[DEBUG_MODULE] DFR KO \n\r" ) );
    }

    end_time = current_timestamp();
    elapsed_time = ( uint32_t ) ( end_time - start_time ) ;
    DEBUG_MODULE ( printf ( "prog.time[ms] %d \n\r", elapsed_time ));

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
callq 0x404b90
movq %rax, -0x10(%rbp)
leaq 0x1a191c(%rip), %rdi    # 0x5a660a
movb $0x0, %al
callq 0x4cc510
cmpl $0x0, %eax
jne 0x404cfc
jmp 0x404cfe
jmp 0x404cfe
callq 0x404b90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
movl %eax, -0x1c(%rbp)
ud2
nopw %cs:(%rax,%rax)
// File: Andrea-Guerrieri[P]LEOSoC/LEOSoC/fpga_if.cpp
// Function: fpi_program_partial(unsigned char, unsigned char)
uint32_t fpi_program_partial ( unsigned char module,  unsigned char region )
{
    char cmd[64];

    set_isolator ( region );

    //SET_PR ( PR_SET );

    //sprintf ( cmd, "%s %s_%d_%d > %s", fpga_program_cmd[run_env] , pl.bit.full_bt_name, region, module );

    while ( PROGRAM_FPGA ( cmd ) )
    {
        usleep ( 1000 );
    }


    reset_isolator ( region );
    reset_tlb ( region );
    reset_pr ( region );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %edi
callq 0x404c70
leaq 0x1a18c6(%rip), %rdi    # 0x5a660a
movb $0x0, %al
callq 0x4cc510
cmpl $0x0, %eax
je 0x404d5c
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x534870
jmp 0x404d3d
movzbl -0x2(%rbp), %edi
callq 0x404ca0
movzbl -0x2(%rbp), %edi
callq 0x404c10
movzbl -0x2(%rbp), %edi
callq 0x404c40
ud2
nopl (%rax)
// File: Andrea-Guerrieri[P]LEOSoC/examples/testapplication.cpp
// Function: main
int main ( int argc, char *argv[] )
{
        
    leosoc_init( TEST_ID );
    
    leosoc_create ( 0, &input_data, &output_data );
    leosoc_create ( 1, &input_data, &output_data );
    leosoc_create ( 2, &input_data, &output_data );
    
    leosoc_join ( 0, TIMEOUT );
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
callq 0x4047e0
xorl %edi, %edi
leaq 0x1f0f56(%rip), %rsi    # 0x5f5cf8
leaq 0x1f0f53(%rip), %rdx    # 0x5f5cfc
callq 0x4048c0
movl $0x1, %edi
leaq 0x1f0f3e(%rip), %rsi    # 0x5f5cf8
leaq 0x1f0f3b(%rip), %rdx    # 0x5f5cfc
callq 0x4048c0
movl $0x2, %edi
leaq 0x1f0f26(%rip), %rsi    # 0x5f5cf8
leaq 0x1f0f23(%rip), %rdx    # 0x5f5cfc
callq 0x4048c0
xorl %edi, %edi
movl $0x5, %esi
callq 0x4049d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jaudoux[P]countTags/src/countTags.cpp
// Function: join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, char const*)
std::string join( const std::vector<std::string>& elements, const char* const separator)
{
  switch (elements.size())
  {
    case 0:
      return "";
    case 1:
      return elements[0];
    default:
      std::ostringstream os;
      std::copy(elements.begin(), elements.end()-1, std::ostream_iterator<std::string>(os, separator));
      os << *elements.rbegin();
      return os.str();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x200(%rbp)
movq %rdi, %rax
movq %rax, -0x1f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4910
movq %rax, %rcx
movq %rcx, -0x1f0(%rbp)
testq %rax, %rax
je 0x3611
jmp 0x3602
movq -0x1f0(%rbp), %rax
subq $0x1, %rax
je 0x3665
jmp 0x3686
leaq -0x19(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0x33c0
movq -0x200(%rbp), %rdi
movq -0x208(%rbp), %rdx
leaq 0xbbc0(%rip), %rsi      # 0xf1f6
callq 0x4930
jmp 0x363d
leaq -0x19(%rbp), %rdi
callq 0x3230
jmp 0x378b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x3230
jmp 0x379b
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49e0
movq -0x200(%rbp), %rdi
movq %rax, %rsi
callq 0x30e0
jmp 0x378b
leaq -0x1a8(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x3300
movq -0x10(%rbp), %rdi
callq 0x4a80
movq %rax, -0x1b0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4ab0
movq %rax, -0x1c0(%rbp)
leaq -0x1c0(%rbp), %rdi
movl $0x1, %esi
callq 0x4ae0
movq -0x210(%rbp), %rsi
movq %rax, -0x1b8(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x1d0(%rbp), %rdi
callq 0x4b20
jmp 0x36ea
movq -0x1b0(%rbp), %rsi
movq -0x1b8(%rbp), %rdx
leaq -0x1e0(%rbp), %rdi
leaq -0x1d0(%rbp), %rcx
callq 0x4a00
jmp 0x370d
movq -0x10(%rbp), %rsi
leaq -0x1e8(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x4b50
movq -0x220(%rbp), %rdi
callq 0x4ba0
movq %rax, -0x218(%rbp)
jmp 0x3739
movq -0x218(%rbp), %rsi
leaq -0x1a8(%rbp), %rdi
callq 0x31b0
jmp 0x374e
movq -0x200(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x3200
jmp 0x3763
leaq -0x1a8(%rbp), %rdi
callq 0x3070
jmp 0x378b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x3070
jmp 0x379b
movq -0x1f8(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: jaudoux[P]countTags/src/dna.h
// Function: DNAtoInt(char const*, unsigned int, bool)
inline uint64_t DNAtoInt(const char *dna, uint32_t dna_length, bool stranded = false){
  uint64_t dna_int = 0;
  for (uint32_t i = 0; i< dna_length ; i++){
    dna_int <<= 2;
    dna_int |= convNuc(dna[i]);
  }
  // If the conversion is not "strand-specific" we calculate the reverse DNA it
  // and return the one that has the smallest value
  if(!stranded) {
    uint64_t rev_comp = intRevcomp(dna_int,dna_length);
    if(rev_comp < dna_int) {
      return rev_comp;
    }
  }
  return dna_int;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x4efe
movq -0x20(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movsbl (%rax,%rcx), %edi
callq 0x6a90
movl %eax, %eax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4ec5
testb $0x1, -0x15(%rbp)
jne 0x4f2a
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6af0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x4f28
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4f32
jmp 0x4f2a
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: jaudoux[P]countTags/src/countTags.cpp
// Function: valns(unsigned int, char*, unsigned int, long*, unsigned long*, unsigned long*, bool)
inline uint64_t valns(uint32_t p, char *dna,uint32_t k,int64_t *last,uint64_t *valfwd,uint64_t *valrev, bool stranded = false){
  int e=p-*last;
  if(e!=1){
    *last=p;
    *valfwd=DNAtoInt(&dna[p], k, true);
    *valrev=intRevcomp(*valfwd, k);
  }else{
    // Compute the new value from the previous one.
    uint64_t m=1;
    *valfwd%=m<<(2*k-2);
    *valfwd<<=2;
    int new_nuc = convNuc(dna[p+k-1]);
    *valfwd += new_nuc;
    *last=p;
    *valrev/=1<<(2);
    *valrev+=(uint64_t)compNuc(new_nuc)<<(2*k-2);
  }
  if(stranded || *valfwd < *valrev) {
    return *valfwd;
  } else {
    return *valrev;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb 0x10(%rbp), %al
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
andb $0x1, %al
movb %al, -0x39(%rbp)
movl -0xc(%rbp), %eax
movq -0x28(%rbp), %rcx
subq (%rcx), %rax
movl %eax, -0x40(%rbp)
cmpl $0x1, -0x40(%rbp)
je 0x50c4
movl -0xc(%rbp), %eax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
addq %rax, %rdi
movl -0x1c(%rbp), %esi
movl $0x1, %edx
callq 0x4ea0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x6af0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
jmp 0x516c
movq $0x1, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq (%rax), %rax
xorl %edx, %edx
divq %rcx
movq -0x58(%rbp), %rax
movq %rdx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rcx
shlq $0x2, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %edi
callq 0x6a90
movl %eax, -0x4c(%rbp)
movslq -0x4c(%rbp), %rcx
movq -0x30(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
shrq $0x2, %rcx
movq %rcx, (%rax)
movl -0x4c(%rbp), %edi
callq 0x6bb0
movl %eax, %eax
movl -0x1c(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
testb $0x1, -0x39(%rbp)
jne 0x5182
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x518f
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x519a
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jaudoux[P]countTags/src/dna.h
// Function: intToDNA(unsigned long, unsigned int, char*)
inline void intToDNA(uint64_t code, uint dna_length, char *dna) {
  uint64_t mask = 3;
  for (uint i=0; i < dna_length; i++) {
    dna[dna_length-i-1] = intToNuc(code & mask);
    code >>=2;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x3, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x5374
movq -0x8(%rbp), %rax
andq -0x20(%rbp), %rax
movl %eax, %edi
callq 0x6c10
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
subl -0x24(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movq %rax, -0x8(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5332
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jaudoux[P]countTags/src/countTags.cpp
// Function: Arg::Numeric(option::Option const&, bool)
static option::ArgStatus Numeric(const option::Option& option, bool msg)
  {
    char* endptr = 0;
    if (option.arg != 0 && strtol(option.arg, &endptr, 10)){};
    if (endptr != option.arg && *endptr == 0)
      return option::ARG_OK;

    if (msg) printError("Option '", option, "' requires a numeric argument\n");
    return option::ARG_ILLEGAL;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x5885
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x20(%rbp), %rsi
movl $0xa, %edx
callq 0x3330
cmpq $0x0, %rax
je 0x5885
jmp 0x5885
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x58a8
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x58a8
movl $0x1, -0x4(%rbp)
jmp 0x58cc
testb $0x1, -0x11(%rbp)
je 0x58c5
movq -0x10(%rbp), %rsi
leaq 0x9a89(%rip), %rdi      # 0xf342
leaq 0x9a8b(%rip), %rdx      # 0xf34b
callq 0x58e0
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::Stats::add(bool, option::Descriptor const*, int, char const**, int, bool)
inline void Stats::add(bool gnu, const Descriptor usage[], int argc, const char** argv, int min_abbr_len,
                       bool single_minus_longopt)
{
  // determine size of options array. This is the greatest index used in the usage + 1
  int i = 0;
  while (usage[i].shortopt != 0)
  {
    if (usage[i].index + 1 >= options_max)
      options_max = (usage[i].index + 1) + 1; // 1 more than necessary as sentinel

    ++i;
  }

  CountOptionsAction action(&buffer_max);
  Parser::workhorse(gnu, usage, argc, argv, action, single_minus_longopt, false, min_abbr_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
andb $0x1, %sil
movb %sil, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
andb $0x1, %al
movb %al, -0x2d(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x59f6
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movl (%rax), %eax
addl $0x1, %eax
cmpl 0x4(%rcx), %eax
jb 0x59eb
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x34(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x599a
movq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x5a50
movb -0x9(%rbp), %dil
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movb -0x2d(%rbp), %r9b
movl -0x2c(%rbp), %eax
leaq -0x48(%rbp), %r8
xorl %r10d, %r10d
andb $0x1, %dil
andb $0x1, %r9b
movzbl %dil, %edi
movzbl %r9b, %r9d
movl $0x0, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x5a90
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::Stats::CountOptionsAction::perform(option::Option&)
bool perform(Option&)
  {
    if (*buffer_max == 0x7fffffff)
      return false; // overflow protection: don't accept number of options that doesn't fit signed int
    ++*buffer_max;
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
cmpl $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
jne 0x6226
movb $0x0, -0x1(%rbp)
jmp 0x6239
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::Parser::shift(char const**, int)
static void shift(const char** args, int count)
  {
    for (int i = 0; i > -count; --i)
    {
      const char* temp = args[i];
      args[i] = args[i - 1];
      args[i - 1] = temp;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
xorl %ecx, %ecx
subl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jle 0x62eb
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6292
popq %rbp
retq
nopl (%rax)
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::Parser::streq(char const*, char const*)
static bool streq(const char* st1, const char* st2)
  {
    while (*st1 != 0)
      if (*st1++ != *st2++)
        return false;
    return (*st2 == 0 || *st2 == '=');
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x6338
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x6336
movb $0x0, -0x1(%rbp)
jmp 0x6361
jmp 0x62fc
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x6359
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::Parser::streqabbr(char const*, char const*, long long)
static bool streqabbr(const char* st1, const char* st2, long long min)
  {
    const char* st1start = st1;
    while (*st1 != 0 && (*st1 == *st2))
    {
      ++st1;
      ++st2;
    }

    return (*st1 == 0 || (min > 0 && (st1 - st1start) >= min)) && (*st2 == 0 || *st2 == '=');
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x63af
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x63b8
jmp 0x63d2
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6388
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x6400
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x22(%rbp)
jle 0x6427
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rax, %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x22(%rbp)
jl 0x6427
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x23(%rbp)
je 0x6421
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
sete %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::Option::init(option::Descriptor const*, char const*, char const*)
void init(const Descriptor* desc_, const char* name_, const char* arg_)
  {
    desc = desc_;
    name = name_;
    arg = arg_;
    prev_ = tag(this);
    next_ = tag(this);
    namelen = 0;
    if (name == 0)
      return;
    namelen = 1;
    if (name[0] != '-')
      return;
    while (name[namelen] != 0 && name[namelen] != '=')
      ++namelen;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x20(%rdi)
callq 0x65a0
movq -0x28(%rbp), %rdi
movq %rax, 0x8(%rdi)
callq 0x65a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, 0x28(%rax)
cmpq $0x0, 0x18(%rax)
jne 0x6534
jmp 0x659a
movq -0x28(%rbp), %rax
movl $0x1, 0x28(%rax)
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x654d
jmp 0x659a
jmp 0x654f
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rax
movslq 0x28(%rcx), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x6582
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rax
movslq 0x28(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x658b
jmp 0x659a
movq -0x28(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x654f
addq $0x30, %rsp
popq %rbp
retq
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::Parser::StoreOptionAction::StoreOptionAction(option::Parser&, option::Option*, option::Option*, int)
StoreOptionAction(Parser& parser_, Option options_[], Option buffer_[], int bufmax_) :
      parser(parser_), options(options_), buffer(buffer_), bufmax(bufmax_)
  {
    // find first empty slot in buffer (if any)
    int bufidx = 0;
    while ((bufmax < 0 || bufidx < bufmax) && buffer[bufidx])
      ++bufidx;

    // set parser's optionCount
    parser.op_count = bufidx;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x61e0
movq -0x30(%rbp), %rax
leaq 0x10664(%rip), %rcx     # 0x16d08
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x20(%rax)
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jl 0x66eb
movq -0x30(%rbp), %rdx
movl -0x28(%rbp), %ecx
xorl %eax, %eax
cmpl 0x20(%rdx), %ecx
movb %al, -0x31(%rbp)
jge 0x670d
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0x28(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x4dd0
cmpq $0x0, %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x6716
jmp 0x6721
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x66d0
movq -0x30(%rbp), %rax
movl -0x28(%rbp), %ecx
movq 0x8(%rax), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::Parser::StoreOptionAction::perform(option::Option&)
bool perform(Option& option)
  {
    if (bufmax < 0 || parser.op_count < bufmax)
    {
      if (parser.op_count == 0x7fffffff)
        return false; // overflow protection: don't accept number of options that doesn't fit signed int

      buffer[parser.op_count] = option;
      int idx = buffer[parser.op_count].desc->index;
      if (options[idx])
        options[idx].append(buffer[parser.op_count]);
      else
        options[idx] = buffer[parser.op_count];
      ++parser.op_count;
    }
    return true; // NOTE: an option that is discarded because of a full buffer is not fatal
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x20(%rax)
jl 0x6771
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movl (%rax), %eax
cmpl 0x20(%rcx), %eax
jge 0x6857
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
jne 0x678a
movb $0x0, -0x1(%rbp)
jmp 0x685b
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rax
movslq (%rax), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x68b0
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rax), %rdx
movslq (%rdx), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x10(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x4dd0
cmpq $0x0, %rax
je 0x681e
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rax
movslq (%rax), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x4dd0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x68f0
jmp 0x6848
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rsi
movq 0x8(%rax), %rcx
movslq (%rcx), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rsi
movq 0x10(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x68b0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::Parser::StoreOptionAction::finished(int, char const**)
bool finished(int numargs, const char** args)
  {
    // only overwrite non-option argument list if there's at least 1
    // new non-option argument. Otherwise we keep the old list. This
    // makes it easy to use default non-option arguments.
    if (numargs > 0)
    {
      parser.nonop_count = numargs;
      parser.nonop_args = args;
    }

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x68a7
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edx
movq 0x8(%rax), %rcx
movl %edx, 0x4(%rcx)
movq -0x18(%rbp), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::Option::append(option::Option*)
void append(Option* new_last)
  {
    Option* p = last();
    Option* f = first();
    p->next_ = new_last;
    new_last->prev_ = p;
    new_last->next_ = tag(f);
    f->prev_ = tag(new_last);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x6970
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x69a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x65a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x65a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::Option::first()
Option* first()
  {
    Option* p = this;
    while (!p->isFirst())
      p = p->prev_;
    return p;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a20
xorb $-0x1, %al
testb $0x1, %al
jne 0x69c5
jmp 0x69d3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x69b4
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jaudoux[P]countTags/src/dna.h
// Function: convNuc(char)
inline uint convNuc(char nuc){
  switch (nuc){
    case 'a' : case 'A' : return 0 ;
    case 'c' : case 'C' : return 1 ;
    case 'g' : case 'G' : return 2 ;
    case 't' : case 'T' : return 3 ;
    default : return 0;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x33, %eax
ja 0x6ae4
movq -0x10(%rbp), %rax
leaq 0x859d(%rip), %rcx      # 0xf054
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x6aeb
movl $0x1, -0x4(%rbp)
jmp 0x6aeb
movl $0x2, -0x4(%rbp)
jmp 0x6aeb
movl $0x3, -0x4(%rbp)
jmp 0x6aeb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: jaudoux[P]countTags/src/dna.h
// Function: intRevcomp(unsigned long, unsigned int)
inline uint64_t intRevcomp(uint64_t factor, uint32_t length) {
  uint64_t mask;
  if (length == 32)
    mask = ~0;
  else
    mask =  ((uint64_t) 1 << (2*length)) - 1;

  factor ^= mask;

  uint64_t mask_lsb;
  // Corresponds to the rightmost nucleotide
  mask_lsb = 3;
  uint64_t shift = 0;
  uint64_t result=0;
  for(uint32_t j(0);j<length;j++){
    result <<= 2;
    // get the leftmost nucleotide and put it at the end
    result |= (factor & mask_lsb) >> shift;
    mask_lsb <<= 2;
    shift += 2;
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jne 0x6b0b
movq $-0x1, -0x18(%rbp)
jmp 0x6b24
movl -0xc(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x3, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x6b9d
movq -0x30(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
andq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
shrq %cl, %rax
orq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6b4f
movq -0x30(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jaudoux[P]countTags/src/dna.h
// Function: compNuc(unsigned int)
inline uint compNuc(uint nuc){
  switch (nuc){
    case 0 : return 3 ;
    case 1 : return 2 ;
    case 2 : return 1 ;
    case 3 : return 0 ;
    default  : return 0;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x6bfc
movq -0x10(%rbp), %rax
leaq 0x8555(%rip), %rcx      # 0xf124
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, -0x4(%rbp)
jmp 0x6c03
movl $0x2, -0x4(%rbp)
jmp 0x6c03
movl $0x1, -0x4(%rbp)
jmp 0x6c03
movl $0x0, -0x4(%rbp)
jmp 0x6c03
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: jaudoux[P]countTags/src/dna.h
// Function: intToNuc(unsigned int)
inline char intToNuc(uint c) {
  switch(c) {
  case 0: return 'A';
  case 1: return 'C';
  case 2: return 'G';
  case 3: return 'T';
  default : return 'A';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x6c50
movq -0x10(%rbp), %rax
leaq 0x8505(%rip), %rcx      # 0xf134
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x41, -0x1(%rbp)
jmp 0x6c54
movb $0x43, -0x1(%rbp)
jmp 0x6c54
movb $0x47, -0x1(%rbp)
jmp 0x6c54
movb $0x54, -0x1(%rbp)
jmp 0x6c54
movb $0x41, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::LinePartIterator::nextTable()
bool nextTable()
    {
      // If this is NOT the first time nextTable() is called after the constructor,
      // then skip to the next table break (i.e. a Descriptor with help == 0)
      if (rowdesc != 0)
      {
        while (tablestart->help != 0 && tablestart->shortopt != 0)
          ++tablestart;
      }

      // Find the next table after the break (if any)
      while (tablestart->help == 0 && tablestart->shortopt != 0)
        ++tablestart;

      restartTable();
      return rowstart != 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x898d
jmp 0x894d
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, -0x11(%rbp)
je 0x8972
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x897b
jmp 0x898b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x28, %rcx
movq %rcx, (%rax)
jmp 0x894d
jmp 0x898d
jmp 0x898f
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, -0x12(%rbp)
jne 0x89b4
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0x89bd
jmp 0x89cd
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x28, %rcx
movq %rcx, (%rax)
jmp 0x898f
movq -0x10(%rbp), %rdi
callq 0x89f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
setne %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::LinePartIterator::nextRow()
bool nextRow()
    {
      if (ptr == 0)
      {
        restartRow();
        return rowstart != 0;
      }

      while (*ptr != 0 && *ptr != '\n')
        ++ptr;

      if (*ptr == 0)
      {
        if ((rowdesc + 1)->help == 0) // table break
          return false;

        ++rowdesc;
        rowstart = rowdesc->help;
      }
      else // if (*ptr == '\n')
      {
        rowstart = ptr + 1;
      }

      restartRow();
      return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
jne 0x8a5a
movq -0x18(%rbp), %rdi
callq 0x9120
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x8b00
jmp 0x8a5c
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x8a85
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x8a8e
jmp 0x8aa0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x8a5c
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x8ae3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x48(%rax)
jne 0x8ac5
movb $0x0, -0x1(%rbp)
jmp 0x8b00
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x28, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x8af3
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x9120
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)