LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movl %edi, %ebx
leaq 0x1819a2(%rip), %rdi    # 0x586034
xorl %eax, %eax
callq 0x4cc000
pushq $0x30
popq %rax
leaq 0x1f0ef5(%rip), %rcx    # 0x5f5598
cmpq $0x1b0, %rax            # imm = 0x1B0
je 0x4046b8
movl $0x5, (%rax,%rcx)
addq $0x30, %rax
jmp 0x4046a3
callq 0x4047f0
testb %al, %al
jne 0x4046cd
movb $0x0, 0x1f0ec8(%rip)    # 0x5f5590
callq 0x404708
movzbl %bl, %edi
callq 0x40487e
leaq 0x1f15dc(%rip), %rdi    # 0x5f5cb8
leaq -0x12b(%rip), %rdx      # 0x4045b8
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x4de260
movslq %ebx, %rcx
leaq 0x1f15ca(%rip), %rax    # 0x5f5cc0
leaq (%rax,%rcx,8), %rdi
leaq -0xd8(%rip), %rdx       # 0x404629
xorl %esi, %esi
callq 0x4de260
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
leaq 0x1818cb(%rip), %rdi    # 0x58605e
movl %ebp, %esi
xorl %eax, %eax
callq 0x4cc000
imull $0x186a0, %ebx, %eax    # imm = 0x186A0
movslq %ebp, %rcx
imulq $0x30, %rcx, %rcx
leaq 0x1f0de8(%rip), %rdx    # 0x5f5598
leaq (%rcx,%rdx), %r14
addq $0x1c, %r14
movl %eax, 0x14(%r14)
pushq $0x1
popq %rbx
cmpl $0x4, 0x8(%r14)
je 0x4047cf
movl %ebx, %edi
callq 0x534370
jmp 0x4047bf
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq $0x1
popq %rbx
movl %ebx, %edi
callq 0x404688
leaq 0x1f144e(%rip), %r14    # 0x5f5cf8
leaq 0x1f144b(%rip), %r15    # 0x5f5cfc
xorl %edi, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x40471e
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x40471e
pushq $0x2
popq %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x40471e
pushq $0x5
popq %rsi
xorl %edi, %edi
callq 0x404784
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax,%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq $0x1, %rax
je 0x24ef
testq %rax, %rax
jne 0x24f9
leaq 0x3c62(%rip), %rsi      # 0x6142
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x2eac
jmp 0x2551
movq %rbx, %rdi
callq 0x2250
jmp 0x2551
movq %rdx, %r15
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x2240
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq $-0x20, %rdx
leaq 0x10(%rsp), %rcx
movq %r12, (%rcx)
movq %r15, 0x8(%rcx)
movq %rsp, %rdi
callq 0x2ee7
movq 0x8(%r14), %rsi
addq $-0x20, %rsi
leaq 0x20(%rsp), %rdi
callq 0x2150
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x22b0
leaq 0x20(%rsp), %rdi
callq 0x2050
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2567
jmp 0x2567
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %eax
xorl %ecx, %ecx
movabsq $0x100000001, %r8       # imm = 0x100000001
pushq $0x1
popq %r9
movabsq $0x1000000010, %r10     # imm = 0x1000000010
pushq $0x2
popq %r11
movabsq $0x2000000020000, %r14  # imm = 0x2000000020000
pushq $0x3
popq %r15
xorl %ebx, %ebx
cmpq %rcx, %rax
je 0x3015
movzbl (%rdi,%rcx), %r12d
addl $-0x43, %r12d
cmpl $0x31, %r12d
ja 0x3010
btq %r12, %r8
jb 0x3001
btq %r12, %r10
jb 0x2ffc
btq %r12, %r14
movl $0x0, %r12d
jae 0x3004
movq %r15, %r12
jmp 0x3004
movq %r11, %r12
jmp 0x3004
movq %r9, %r12
shlq $0x2, %rbx
orq %r12, %rbx
incq %rcx
jmp 0x2fcb
xorl %r12d, %r12d
jmp 0x3004
testb %dl, %dl
jne 0x3026
movq %rbx, %rdi
callq 0x3980
cmpq %rbx, %rax
jb 0x3029
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %rax
movl %edx, %r12d
movb 0x30(%rsp), %bpl
movl %edi, %edx
movl %edi, %ecx
subl (%rax), %ecx
cmpl $0x1, %ecx
jne 0x30ed
leal -0x2(,%r12,2), %r15d
pushq $-0x1
popq %r8
movl %r15d, %ecx
shlq %cl, %r8
notq %r8
andq (%rbx), %r8
shlq $0x2, %r8
movq %r8, (%rbx)
leal (%rdi,%r12), %ecx
decl %ecx
movzbl (%rsi,%rcx), %ecx
xorl %edi, %edi
addl $-0x43, %ecx
cmpl $0x31, %ecx
ja 0x3118
movabsq $0x100000001, %rsi      # imm = 0x100000001
btq %rcx, %rsi
jb 0x3115
movabsq $0x1000000010, %rsi     # imm = 0x1000000010
btq %rcx, %rsi
jb 0x3111
movabsq $0x2000000020000, %rsi  # imm = 0x2000000020000
btq %rcx, %rsi
jae 0x3118
pushq $0x3
jmp 0x3117
movq %rdx, (%rax)
addq %rdx, %rsi
pushq $0x1
popq %rdx
movq %rsi, %rdi
movl %r12d, %esi
callq 0x2f93
movq %rax, (%rbx)
movq %rax, %rdi
movl %r12d, %esi
callq 0x3980
jmp 0x3137
pushq $0x2
jmp 0x3117
pushq $0x1
popq %rdi
movl %edi, %ecx
orq %rcx, %r8
movq %r8, (%rbx)
movq %rdx, (%rax)
shrq $0x2, (%r14)
callq 0x39c0
movl %eax, %eax
movl %r15d, %ecx
shlq %cl, %rax
addq (%r14), %rax
movq %rax, (%r14)
movq (%rbx), %rcx
cmpq %rax, %rcx
cmovbq %rcx, %rax
testb %bpl, %bpl
cmovneq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %esi, %eax
testq %rax, %rax
je 0x3198
leal (,%rdi,8), %ecx
movl $0x54474341, %esi       # imm = 0x54474341
shrl %cl, %esi
decq %rax
movl %eax, %ecx
movb %sil, (%rdx,%rcx)
shrq $0x2, %rdi
jmp 0x3176
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
andq $0x0, (%rsp)
movq %rdi, %r14
movq 0x20(%rdi), %rdi
pushq $0x3
popq %rbx
testq %rdi, %rdi
je 0x31ea
movq %rsp, %r15
pushq $0xa
popq %rdx
movq %r15, %rsi
callq 0x2260
movq (%r15), %rcx
cmpq 0x20(%r14), %rcx
je 0x31ea
xorl %eax, %eax
cmpb $0x0, (%rcx)
setne %cl
testb %bpl, %cl
jne 0x31ef
movb %cl, %al
leal 0x1(,%rax,2), %ebx
jmp 0x3205
testb %bpl, %bpl
je 0x3205
leaq 0x3098(%rip), %rdi      # 0x628e
leaq 0x309a(%rip), %rdx      # 0x6297
movq %r14, %rsi
callq 0x3212
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x18, %rsp
movl %r9d, %eax
movq %r8, %r10
movb 0x30(%rsp), %r9b
movl 0x4(%rdi), %r11d
leaq 0x8(%rdx), %r8
cmpq $0x0, (%r8)
je 0x3296
movl -0x8(%r8), %ebx
leal 0x1(%rbx), %ebp
cmpl %r11d, %ebp
jb 0x3290
addl $0x2, %ebx
movl %ebx, 0x4(%rdi)
movl %ebx, %r11d
addq $0x28, %r8
jmp 0x3275
leaq 0x6a53(%rip), %r11      # 0x9cf0
leaq 0x8(%rsp), %r8
movq %r11, (%r8)
movq %rdi, 0x8(%r8)
movzbl %sil, %edi
movzbl %r9b, %r9d
movq %rdx, %rsi
movl %ecx, %edx
movq %r10, %rcx
pushq %rax
pushq $0x0
callq 0x32c8
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
negl %esi
movslq %esi, %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jle 0x3700
movdqu -0x8(%rdi,%rcx,8), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, -0x8(%rdi,%rcx,8)
decq %rcx
jmp 0x36e5
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
movb (%rdi,%rax), %r8b
movb (%rsi,%rax), %cl
testb %r8b, %r8b
je 0x3757
cmpb %cl, %r8b
jne 0x3742
incq %rax
jmp 0x372c
testq %rdx, %rdx
setle %sil
cmpq %rdx, %rax
setl %al
orb %sil, %al
je 0x3757
xorl %eax, %eax
retq
testb %cl, %cl
sete %dl
cmpb $0x3d, %cl
sete %al
orb %dl, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rdi, %rax
orq $0x1, %rax
movq %rax, 0x8(%rdi)
movq %rax, (%rdi)
andl $0x0, 0x28(%rdi)
testq %rdx, %rdx
je 0x37c3
movl $0x1, 0x28(%rdi)
cmpb $0x2d, (%rdx)
jne 0x37c3
pushq $0x1
popq %rax
movzbl (%rdx,%rax), %ecx
testl %ecx, %ecx
je 0x37c3
cmpl $0x3d, %ecx
je 0x37c3
incq %rax
movl %eax, 0x28(%rdi)
jmp 0x37ae
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
leaq 0x64ff(%rip), %rax      # 0x9d38
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movl %r8d, 0x20(%rdi)
movl %r8d, %eax
leaq 0x10(%rcx), %rdi
xorl %edx, %edx
testl %r8d, %r8d
sets %r9b
cmpq %rax, %rdx
setb %r10b
orb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x3880
testq %rcx, %rcx
je 0x3880
cmpq $0x0, (%rdi)
je 0x3880
incq %rdx
addq $0x30, %rdi
jmp 0x3855
movl %edx, (%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %edx
movq 0x8(%rdi), %rax
movslq (%rax), %rcx
testl %edx, %edx
js 0x389e
movb $0x1, %al
cmpl %edx, %ecx
jl 0x38aa
jmp 0x38ff
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
jne 0x38aa
xorl %eax, %eax
jmp 0x38ff
imulq $0x30, %rcx, %rdi
addq 0x18(%rbx), %rdi
callq 0x3914
movq 0x18(%rbx), %rcx
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rax
movslq (%rdx), %rdx
imulq $0x30, %rdx, %rdx
leaq (%rcx,%rdx), %rsi
movq 0x10(%rcx,%rdx), %rcx
movslq (%rcx), %rcx
imulq $0x30, %rcx, %rcx
leaq (%rax,%rcx), %rdi
testq %rax, %rax
je 0x38f2
cmpq $0x0, 0x10(%rax,%rcx)
je 0x38f2
callq 0x3928
jmp 0x38f7
callq 0x3914
movq 0x8(%rbx), %rax
incl (%rax)
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3962
movq %rax, %r15
movq %r14, %rdi
callq 0x3972
movq %rbx, (%r15)
movq %r15, 0x8(%rbx)
movq %rax, %rcx
orq $0x1, %rcx
movq %rcx, (%rbx)
orq $0x1, %rbx
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
leal (%rsi,%rsi), %ecx
pushq $-0x1
popq %rax
movq %rax, %rdx
shlq %cl, %rdx
cmpl $0x20, %esi
notq %rdx
cmoveq %rax, %rdx
xorq %rdi, %rdx
pushq $0x3
popq %rdi
xorl %ecx, %ecx
xorl %eax, %eax
subl $0x1, %esi
jb 0x39bf
movq %rdi, %r8
andq %rdx, %r8
shrq %cl, %r8
shlq $0x2, %rax
orq %r8, %rax
shlq $0x2, %rdi
addq $0x2, %rcx
jmp 0x39a0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq $0x0, 0x8(%rdi)
movq (%rdi), %rax
je 0x4179
addq $0x28, %rax
cmpq $0x0, -0x8(%rax)
je 0x4175
cmpq $0x0, -0x20(%rax)
je 0x4175
movq %rax, (%rdi)
jmp 0x415e
addq $-0x28, %rax
addq $0x28, %rax
movq -0x8(%rax), %rcx
testq %rcx, %rcx
jne 0x4192
cmpq $0x0, -0x20(%rax)
je 0x4192
movq %rax, (%rdi)
jmp 0x4179
addq $-0x28, %rax
movq %rax, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
testq %rcx, %rcx
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x41c9
incq %rax
movzbl -0x1(%rax), %ecx
testl %ecx, %ecx
je 0x41eb
cmpl $0xa, %ecx
je 0x4200
movq %rax, 0x18(%rdi)
jmp 0x41b3
movq 0x10(%rdi), %rax
movq %rax, 0x18(%rdi)
orl $-0x1, 0x20(%rdi)
xorps %xmm0, %xmm0
andl $0x0, 0x34(%rdi)
movups %xmm0, 0x24(%rdi)
movb $0x1, 0x38(%rdi)
testq %rax, %rax
setne %al
retq
movq 0x8(%rdi), %rcx
movq 0x48(%rcx), %rax
testq %rax, %rax
je 0x421e
addq $0x28, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
orl $-0x1, 0x20(%rdi)
andl $0x0, 0x34(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rdi)
movb $0x1, 0x38(%rdi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::LinePartIterator::next()
bool next()
    {
      if (ptr == 0)
        return false;

      if (col == -1)
      {
        col = 0;
        update_length();
        return true;
      }

      ptr += len;
      while (true)
      {
        switch (*ptr)
        {
          case '\v':
            upmax(max_line_in_block, ++line_in_block);
            ++ptr;
            break;
          case '\t':
            if (!hit_target_line) // if previous column did not have the targetline
            { // then "insert" a 0-length part
              update_length();
              hit_target_line = true;
              return true;
            }

            hit_target_line = false;
            line_in_block = 0;
            ++col;
            ++ptr;
            break;
          case 0:
          case '\n':
            if (!hit_target_line) // if previous column did not have the targetline
            { // then "insert" a 0-length part
              update_length();
              hit_target_line = true;
              return true;
            }

            if (++target_line_in_block > max_line_in_block)
            {
              update_length();
              return false;
            }

            hit_target_line = false;
            line_in_block = 0;
            col = 0;
            ptr = rowstart;
            continue;
          default:
            ++ptr;
            continue;
        } // switch

        if (line_in_block == target_line_in_block)
        {
          update_length();
          hit_target_line = true;
          return true;
        }
      } // while
    }

// Assembly:
movq 0x18(%rdi), %rdx
testq %rdx, %rdx
je 0x42fb
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %esi
cmpl $-0x1, %esi
je 0x42fe
movslq 0x24(%rbx), %rax
addq %rax, %rdx
movq %rdx, 0x18(%rbx)
movq 0x10(%rbx), %rax
movb 0x38(%rbx), %r9b
movl 0x34(%rbx), %edi
movl 0x2c(%rbx), %ecx
movl 0x30(%rbx), %r8d
movzbl (%rdx), %r10d
testl %r10d, %r10d
je 0x427f
cmpl $0xa, %r10d
je 0x427f
cmpl $0x9, %r10d
je 0x42c4
cmpl $0xb, %r10d
je 0x42b1
incq %rdx
movl %edi, %r10d
jmp 0x42a8
testb $0x1, %r9b
je 0x42ed
leal 0x1(%rdi), %r10d
movl %r10d, 0x34(%rbx)
cmpl %ecx, %edi
jge 0x430e
movb $0x0, 0x38(%rbx)
andl $0x0, 0x30(%rbx)
andl $0x0, 0x20(%rbx)
xorl %r8d, %r8d
movq %rax, %rdx
xorl %r9d, %r9d
xorl %esi, %esi
movq %rdx, 0x18(%rbx)
movl %r10d, %edi
jmp 0x425c
incl %r8d
movl %r8d, 0x30(%rbx)
cmpl %r8d, %ecx
cmovlel %r8d, %ecx
movl %ecx, 0x2c(%rbx)
jmp 0x42dd
testb $0x1, %r9b
je 0x42ed
movb $0x0, 0x38(%rbx)
andl $0x0, 0x30(%rbx)
incl %esi
movl %esi, 0x20(%rbx)
xorl %r8d, %r8d
xorl %r9d, %r9d
incq %rdx
movq %rdx, 0x18(%rbx)
cmpl %edi, %r8d
jne 0x425c
movq %rbx, %rdi
callq 0x4584
movb $0x1, 0x38(%rbx)
jmp 0x430a
xorl %eax, %eax
retq
andl $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x4584
movb $0x1, %al
jmp 0x4318
movq %rbx, %rdi
callq 0x4584
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::indent(option::PrintUsageImplementation::IStringWriter&, int&, int)
static void indent(IStringWriter& write, int& x, int want_x)
  {
    int indent = want_x - x;
    if (indent < 0)
    {
      write("\n", 1);
      indent = want_x;
    }

    if (indent > 0)
    {
      char space = ' ';
      for (int i = 0; i < indent; ++i)
        write(&space, 1);
      x = want_x;
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r13d
subl (%rsi), %r13d
jns 0x434a
movq (%r15), %rax
leaq 0x1f75(%rip), %rsi      # 0x62b4
pushq $0x1
popq %rdx
movq %r15, %rdi
callq *(%rax)
movl %ebx, %r13d
testl %r13d, %r13d
jle 0x4374
leaq 0x7(%rsp), %r12
movb $0x20, (%r12)
pushq $0x1
popq %rbp
subl $0x1, %r13d
jb 0x4371
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq *(%rax)
jmp 0x435c
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::LinePartIterator::update_length()
void update_length()
    {
      screenlen = 0;
      for (len = 0; ptr[len] != 0 && ptr[len] != '\v' && ptr[len] != '\t' && ptr[len] != '\n'; ++len)
      {
        ++screenlen;
        unsigned ch = (unsigned char) ptr[len];
        if (ch > 0xC1) // everything <= 0xC1 (yes, even 0xC1 itself) is not a valid UTF-8 start byte
        {
          // int __builtin_clz (unsigned int x)
          // Returns the number of leading 0-bits in x, starting at the most significant bit
          unsigned mask = (unsigned) -1 >> __builtin_clz(ch ^ 0xff);
          ch = ch & mask; // mask out length bits, we don't verify their correctness
          while (((unsigned char) ptr[len + 1] ^ 0x80) <= 0x3F) // while next byte is continuation byte
          {
            ch = (ch << 6) ^ (unsigned char) ptr[len + 1] ^ 0x80; // add continuation to char code
            ++len;
          }
          // ch is the decoded unicode code point
          if (ch >= 0x1100 && isWideChar(ch)) // the test for 0x1100 is here to avoid the function call in the Latin case
            ++screenlen;
        }
      }
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x28(%rdi)
xorl %eax, %eax
movl $0xe01, %ebp            # imm = 0xE01
movl %eax, 0x24(%rbx)
movq 0x18(%rbx), %rdx
movslq %eax, %rsi
movzbl (%rdx,%rsi), %eax
cmpl $0xb, %eax
ja 0x45ad
btl %eax, %ebp
jb 0x4619
incl 0x28(%rbx)
movzbl (%rdx,%rsi), %edi
cmpl $0xc2, %edi
jb 0x460f
movl %edi, %eax
xorl $0xff, %eax
bsrl %eax, %ecx
notl %ecx
shll %cl, %edi
shrl %cl, %edi
leal 0x1(%rsi), %eax
leaq (%rdx,%rsi), %rcx
incq %rcx
movzbl (%rcx), %edx
movl %edx, %esi
xorl $0x80, %esi
cmpl $0x3f, %esi
ja 0x45fb
shll $0x6, %edi
xorl %edx, %edi
xorl $0x80, %edi
movl %eax, 0x24(%rbx)
incl %eax
incq %rcx
jmp 0x45d6
cmpl $0x1100, %edi           # imm = 0x1100
jb 0x460f
callq 0x4620
testb %al, %al
je 0x460f
incl 0x28(%rbx)
movl 0x24(%rbx), %eax
incl %eax
jmp 0x4595
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jaudoux[P]countTags/src/optionparser.h
// Function: option::PrintUsageImplementation::LineWrapper::write_one_line(option::PrintUsageImplementation::IStringWriter&)
void write_one_line(IStringWriter& write)
    {
      if (wrote_something) // if we already wrote something, we need to start a new line
      {
        write("\n", 1);
        int _ = 0;
        indent(write, _, x);
      }

      if (!buf_empty())
      {
        buf_next();
        write(datbuf[tail], lenbuf[tail]);
      }

      wrote_something = true;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0xd0(%rdi)
jne 0x4719
movq (%r14), %rax
leaq 0x1bb9(%rip), %rsi      # 0x62b4
pushq $0x1
popq %rdx
movq %r14, %rdi
callq *(%rax)
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
movl 0xc0(%rbx), %edx
movq %r14, %rdi
callq 0x431a
movl 0xcc(%rbx), %eax
incl %eax
andl $0xf, %eax
cmpl 0xc8(%rbx), %eax
je 0x4744
movl %eax, 0xcc(%rbx)
movl %eax, %eax
movq 0x40(%rbx,%rax,8), %rsi
movl (%rbx,%rax,4), %edx
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movb $0x1, 0xd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jaudoux[P]countTags/src/CountsTable.cpp
// Function: CountsTable::getCount(unsigned long, unsigned int)
uint32_t CountsTable::getCount(uint64_t kmer, uint sample_id) {
  std::unordered_map<uint64_t,uint32_t*>::iterator it_counts = tags_counts.find(kmer);
  // If the tag is already in the hash, we set the count for this->sample
  if(it_counts != tags_counts.end()) {
    return it_counts->second[sample_id];
  } else {
    return 0;
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x57c8
testq %rax, %rax
je 0x52e7
movq 0x10(%rax), %rax
movl %ebx, %ecx
movl (%rax,%rcx,4), %eax
jmp 0x52e9
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jaudoux[P]countTags/src/CountsTable.cpp
// Function: CountsTable::setCount(unsigned long, unsigned int, unsigned int)
void CountsTable::setCount(uint64_t kmer, uint sample_id, uint value) {
  std::unordered_map<uint64_t,uint32_t*>::iterator it_counts = tags_counts.find(kmer);
  // If the tag is already in the hash, we set the count for this->sample
  if(it_counts != tags_counts.end()) {
    it_counts->second[sample_id] = value;
  // Otherwise we create a new entry
  } else {
    uint32_t * tag_counts = new uint32_t[this->nb_samples]();
    tag_counts[sample_id] = value;
    tags_counts[kmer] = tag_counts;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x57c8
testq %rax, %rax
je 0x5353
movq 0x10(%rax), %rax
movl %ebp, %ecx
movl %ebx, (%rax,%rcx,4)
jmp 0x5389
movl 0x50(%r14), %r15d
shlq $0x2, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20f0
movl %ebp, %eax
movl %ebx, (%r12,%rax,4)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5844
movq %r12, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jaudoux[P]countTags/src/CountsTable.cpp
// Function: CountsTable::recurrencyFilter(unsigned int)
void CountsTable::recurrencyFilter(uint recurrency_threshold) {
  std::unordered_map<uint64_t,uint32_t*>::iterator it_counts = this->tags_counts.begin();
  while(it_counts != this->tags_counts.end()) {
    uint recurrency = 0;
    for (int s = 0; s < this->nb_samples; ++s) {
      if(it_counts->second[s] > 0) {
        recurrency++;
      }
    }
    if(recurrency >= recurrency_threshold) {
      it_counts++;
    } else {
      it_counts = this->tags_counts.erase(it_counts);
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x543d
movl 0x50(%r14), %ecx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rdx, %rcx
je 0x5427
movq 0x10(%rax), %rdi
cmpl $0x1, (%rdi,%rdx,4)
sbbl $-0x1, %esi
incq %rdx
jmp 0x5412
cmpl %ebx, %esi
jae 0x5438
movq %r14, %rdi
movq %rax, %rsi
callq 0x5b2e
jmp 0x5405
movq (%rax), %rax
jmp 0x5405
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jaudoux[P]countTags/src/CountsTable.cpp
// Function: CountsTable::printCounts(char)
void CountsTable::printCounts(char sep) {
  char *tag_seq = new char[this->kmer_length];
  std::unordered_map<uint64_t,uint32_t*>::iterator it_counts;

  /* Print Headers */
  std::cout << "tag";
  for (int s = 0; s < this->nb_samples; ++s) {
    std::cout << sep << this->sample_names[s];
  }
  std::cout << std::endl;

  /* Print Counts */
  for (it_counts = tags_counts.begin(); it_counts != tags_counts.end(); ++it_counts) {
    intToDNA(it_counts->first,this->kmer_length,tag_seq);
    std::cout << tag_seq;
    for (int s = 0; s < this->nb_samples; ++s) {
      std::cout << "\t" << it_counts->second[s];
    }
    std::cout << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x54(%rdi), %edi
callq 0x2030
movq %rax, %r14
movq 0x4b58(%rip), %r15      # 0x9fc0
leaq 0xcc3(%rip), %rsi       # 0x6132
movq %r15, %rdi
callq 0x2160
xorl %r12d, %r12d
movsbl %bpl, %ebp
xorl %r13d, %r13d
movl 0x50(%rbx), %eax
cmpq %rax, %r13
jae 0x54ab
movq %r15, %rdi
movl %ebp, %esi
callq 0x21c0
movq 0x38(%rbx), %rsi
addq %r12, %rsi
movq %rax, %rdi
callq 0x2150
incq %r13
addq $0x20, %r12
jmp 0x5481
movq 0x4b0e(%rip), %r15      # 0x9fc0
movq %r15, %rdi
callq 0x20d0
leaq 0x10(%rbx), %r13
leaq 0xc7c(%rip), %r12       # 0x6141
movq (%r13), %r13
testq %r13, %r13
je 0x5518
movq 0x8(%r13), %rdi
movl 0x54(%rbx), %esi
movq %r14, %rdx
callq 0x3174
movq %r15, %rdi
movq %r14, %rsi
callq 0x2160
xorl %ebp, %ebp
movl 0x50(%rbx), %eax
movq %r15, %rdi
cmpq %rax, %rbp
jae 0x5511
movq %r12, %rsi
callq 0x2160
movq 0x10(%r13), %rcx
movl (%rcx,%rbp,4), %esi
movq %rax, %rdi
callq 0x2100
incq %rbp
jmp 0x54ea
callq 0x20d0
jmp 0x54c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kuszmaul[P]6886/timers.cc
// Function: loop()
double loop(void) {
    for (size_t t = 0; t < N; t++) {
        for (size_t j = 0; j < N; j++) {
            x[j] += sin(x[j]);
        }
    }
    double sum = 0;
    for (size_t j = 0; j < N; j++) {
        sum += x[j];
    }
    return sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %r14d, %r14d
leaq 0x2e40(%rip), %rbx      # 0x4080
cmpq $0x100, %r14            # imm = 0x100
je 0x1277
xorl %r15d, %r15d
cmpq $0x800, %r15            # imm = 0x800
je 0x1272
movsd (%r15,%rbx), %xmm0
callq 0x1040
addsd (%r15,%rbx), %xmm0
movsd %xmm0, (%r15,%rbx)
addq $0x8, %r15
jmp 0x124c
incq %r14
jmp 0x1240
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x800, %rax            # imm = 0x800
je 0x1290
addsd (%rax,%rbx), %xmm0
addq $0x8, %rax
jmp 0x127d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kuszmaul[P]6886/timers.cc
// Function: timeit_gettimeofday()
void timeit_gettimeofday(void) {
    struct timeval start, end;
    printf("gettimeofday:\n");
    statistics stats;
    for (int trial = 0; trial < n_trials; trial++) {
        init();
        gettimeofday(&start, NULL);
        loop();
        gettimeofday(&end,   NULL);
        double tim = tdiff_timeval(&start, &end);
        stats.measurement(tim);
        printf(" %12.9fs\n", tim);
    }
    stats.print();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq 0xe45(%rip), %rdi       # 0x20ef
callq 0x1090
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
andq $0x0, 0x20(%rbx)
xorl %r13d, %r13d
leaq 0x20(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0xd69(%rip), %r12       # 0x2040
cmpl 0x2d8a(%rip), %r13d     # 0x4068
jge 0x134b
callq 0x11f6
movq %r14, %rdi
xorl %esi, %esi
callq 0x10a0
callq 0x1231
movq %r15, %rdi
xorl %esi, %esi
callq 0x10a0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq 0x20(%rsp), %rax
cvtsi2sd %rax, %xmm1
subq 0x28(%rsp), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0xce4(%rip), %xmm0      # 0x2008
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x14c6
movq %r12, %rdi
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x1030
incl %r13d
jmp 0x12d7
leaq 0x30(%rsp), %rdi
callq 0x1518
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kuszmaul[P]6886/timers.cc
// Function: timeit_clock_gettime(int, char const*)
void timeit_clock_gettime(clockid_t clk_id, const char *string) {
    struct timespec start, end;
    printf("%s\n", string);
    statistics stats;
    for (int trial = 0; trial < n_trials; trial++) {
        init();
        clock_gettime(clk_id, &start);
        loop();
        clock_gettime(clk_id, &end);
        double tim = tdiff_timespec(&start, &end);
        stats.measurement(tim);
        printf(" %12.9fs\n", tim);
    }
    stats.print();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edi, %ebx
movq %rsi, %rdi
callq 0x1090
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
andq $0x0, 0x20(%r14)
xorl %ebp, %ebp
leaq 0x20(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0xc9c(%rip), %r13       # 0x2040
cmpl 0x2cbe(%rip), %ebp      # 0x4068
jge 0x1416
callq 0x11f6
movl %ebx, %edi
movq %r15, %rsi
callq 0x1080
callq 0x1231
movl %ebx, %edi
movq %r12, %rsi
callq 0x1080
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq 0x20(%rsp), %rax
cvtsi2sd %rax, %xmm1
subq 0x28(%rsp), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0xc20(%rip), %xmm0      # 0x2010
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x14c6
movq %r13, %rdi
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x1030
incl %ebp
jmp 0x13a4
leaq 0x30(%rsp), %rdi
callq 0x1518
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kuszmaul[P]6886/timers.cc
// Function: main
int main(int argc __attribute__((unused)), const char *argv[] __attribute__((unused))) {

    timeit_gettimeofday();
    CGT(REALTIME);
    CGT(MONOTONIC);
    CGT(REALTIME_COARSE);
    CGT(MONOTONIC);
    CGT(MONOTONIC_COARSE);
    CGT(MONOTONIC_RAW);
    CGT(BOOTTIME);
    CGT(PROCESS_CPUTIME_ID);
    CGT(THREAD_CPUTIME_ID);
    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x1296
leaq 0xc0c(%rip), %rsi       # 0x204a
xorl %edi, %edi
callq 0x1363
leaq 0xc07(%rip), %rbx       # 0x2053
pushq $0x1
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1363
leaq 0xbfd(%rip), %rsi       # 0x205d
pushq $0x5
popq %rdi
callq 0x1363
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1363
leaq 0xbf4(%rip), %rsi       # 0x206d
pushq $0x6
popq %rdi
callq 0x1363
leaq 0xbf6(%rip), %rsi       # 0x207e
pushq $0x4
popq %rdi
callq 0x1363
leaq 0xbf5(%rip), %rsi       # 0x208c
pushq $0x7
popq %rdi
callq 0x1363
leaq 0xbef(%rip), %rsi       # 0x2095
pushq $0x2
popq %rdi
callq 0x1363
leaq 0xbf3(%rip), %rsi       # 0x20a8
pushq $0x3
popq %rdi
callq 0x1363
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kuszmaul[P]6886/timers.cc
// Function: statistics::measurement(double)
void measurement(double f) {
        if (n == 0) {
            min = max = f;
        } else {
            min = std::min(min, f);
            max = std::max(max, f);
        }
        sum += f;
        sum_squares += f*f;
        n++;
    }

// Assembly:
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x14e7
movapd %xmm0, %xmm1
minsd (%rdi), %xmm1
movapd %xmm0, %xmm2
maxsd 0x8(%rdi), %xmm2
movsd %xmm2, 0x8(%rdi)
jmp 0x14f0
movsd %xmm0, 0x8(%rdi)
movapd %xmm0, %xmm1
movsd %xmm1, (%rdi)
movsd 0x10(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdi)
mulsd %xmm0, %xmm0
addsd 0x18(%rdi), %xmm0
movsd %xmm0, 0x18(%rdi)
incq %rax
movq %rax, 0x20(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: printv(std::vector<int, std::allocator<int>>)
void printv(vector<int> v)
{
    cout << "v(" << v.size() << "): ";
    for (unsigned i = 0; i < v.size(); i++)
        cout << v[i] << " ";
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x5c97(%rip), %r14      # 0x6fd8
leaq 0x2ce8(%rip), %rsi      # 0x4030
movq %r14, %rdi
callq 0x1100
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x2, %rsi
movq %rax, %rdi
callq 0x10c0
leaq 0x2cc9(%rip), %rsi      # 0x4033
movq %rax, %rdi
callq 0x1100
xorl %eax, %eax
leaq 0x2f3b(%rip), %r15      # 0x42b6
movl %eax, %r12d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x13af
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x11d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x1100
leal 0x1(%r12), %eax
jmp 0x137b
movq 0x5c22(%rip), %rdi      # 0x6fd8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: make2f(std::vector<int, std::allocator<int>>, int, int)
vector<int> make2f(vector<int> choices, int f, int i)
{
    int N = 3 * f + 1;
    vector<int> options;
    for (unsigned k = 0; k < N; k++)
        if ((k != i) && (choices[k] != -2) && (k != choices[i])) // not i and non-faulty
                                                                 // (last is to avoid repetition of response): R_2 | 0(0) |    0(2)    0(0)    | Cancel 0
            options.push_back(k);
    std::random_shuffle(options.begin(), options.end());
    // must add i as first on its list, if not proposer
    if (i > 1)                              // non-primary {0,1}
        options.insert(options.begin(), i); // insert first prepare response (choice)
    while (options.size() > 2 * f)
        options.pop_back();
    // must verify that, if responded to a second request, it's relaying first its response, than request itself (priority)
    // example: I answer to Prop1 first, then I receive Prop0... If I decide to also respond to it, I may prefer the response, than the request (it's more info)
    // perhaps a problem o logic in this method here... suppose I'm 2.. if I had choice 1, used 2 to respond to 1.. I cannot respond to 0 (2 was used already). Must do this outside this method.
    // TODO: must improve this, change this method signature with more precise info (value/origin)
    // This is the bug: R_3 | 1(1) |    1(3)    0(0)    | Cancel 1
    // Should respond to zero first with my index, than just prepare request

    return options;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %ecx, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leal 0x1(%rdx,%rdx,2), %r12d
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
andq $0x0, 0x10(%rdi)
movl %ecx, %r13d
movslq %ecx, %r15
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x15ad
cmpq %r14, %r13
je 0x15a8
movq (%rbx), %rax
cmpl $-0x2, (%rax,%r14,4)
je 0x15a8
movl (%rax,%r15,4), %eax
cmpq %rax, %r14
je 0x15a8
movl %r14d, -0x34(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x3306
incq %r14
jmp 0x157a
movq -0x30(%rbp), %rbx
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x2f1e
cmpl $0x2, %r13d
jl 0x15d2
movq (%rbx), %rsi
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x2f7c
movq -0x40(%rbp), %rax
addl %eax, %eax
cltq
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq (%rbx), %rdx
addq $-0x4, %rcx
movq %rdx, %rsi
sarq $0x2, %rsi
cmpq %rax, %rsi
jbe 0x15fe
movq %rcx, 0x8(%rbx)
addq $-0x4, %rdx
jmp 0x15e4
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1614
jmp 0x1614
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x322c
movq %r14, %rdi
callq 0x11e0
// File: /workspace/github_cpp_makefile_star2_O2/NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: getCancels(std::vector<int, std::allocator<int>>, std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>, std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>, int)
vector<int> getCancels(vector<int> choices, vector<vector<pair<int, int>>> selections, int f)
{
    int N = 3 * f + 1;
    vector<int> cancels(N, -2);
    // compute cancels for each replica
    // OLD // rule is: order by lowest to highest proposal, and take value 2*f
    // NEW RULE (simpler): if Prep0 has a non-faulty proposal, Cancel 0, otherwise Cancel 1
    for (unsigned i = 0; i < N; i++)
    {
        if (choices[i] == -2)
            continue;       // faulty node
        int count_zero = 0; // try to Cancel 0 (NEW RULE)
        //vector<int> responses;
        //responses.push_back(choices[i]); // own choice counts
        //for (unsigned j = 0; j < selections[i].size(); j++)
        //    responses.push_back(selections[i][j].second);
        ////cout << "RESPONSES FOR I=" << i << endl;
        ////printv(responses);
        //sort(responses.begin(), responses.end());
        //printv(responses);
        //int cancel = responses[2 * f - 1];
        for (unsigned j = 0; j < selections[i].size(); j++)
            if (selections[i][j].second == 0)
                count_zero++;
        if (choices[i] == 0)
            count_zero++;
        int cancel = 1;          // default one
        if (count_zero >= f + 1) // at least one trusted
            cancel = 0;

        ////cout << "cancel = " << cancel << endl;
        cancels[i] = cancel;
        // EXCEPTION: proposal j cannot Cancel more than j (otherwise it just assumes its "faultyness", what is absurd)
        if (i == 0)
            cancels[i] = 0; // FORCE. could do same for i=1 (but only two, so that's fine already)
    }

    return cancels;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leal 0x1(%rbx,%rbx,2), %r13d
movslq %r13d, %rsi
leaq -0x30(%rbp), %rdx
movl $0xfffffffe, (%rdx)     # imm = 0xFFFFFFFE
leaq -0x29(%rbp), %rcx
callq 0x2ebe
xorl %eax, %eax
cmpq %r13, %rax
je 0x18e3
movq (%r12), %rcx
movl (%rcx,%rax,4), %ecx
cmpl $-0x2, %ecx
je 0x18de
movq (%r14), %rsi
imulq $0x18, %rax, %rdi
movq (%rsi,%rdi), %rdx
movq 0x8(%rsi,%rdi), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movl %r8d, %r8d
cmpq %r8, %rsi
jbe 0x18bf
cmpl $0x1, 0x4(%rdx,%r8,8)
adcl $0x0, %edi
incl %r8d
jmp 0x18a9
cmpl $0x1, %ecx
adcl $0x0, %edi
cmpl %ebx, %edi
setle %cl
movq (%r15), %rdx
testq %rax, %rax
setne %sil
andb %cl, %sil
movzbl %sil, %ecx
movl %ecx, (%rdx,%rax,4)
incq %rax
jmp 0x187c
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: printTable(std::vector<int, std::allocator<int>>, std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>, std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>, std::vector<int, std::allocator<int>>, int)
void printTable(vector<int> choices, vector<vector<pair<int, int>>> selections, vector<int> cancels, int f)
{
    int N = 3 * f + 1;
    for (unsigned i = 0; i < N; i++)
    {
        cout << "R_" << i << " | " << choices[i] << "(" << choices[i] << ") |\t";
        for (unsigned j = 0; j < selections[i].size(); j++)
            cout << selections[i][j].second << "(" << selections[i][j].first << ")\t";
        cout << "| Cancel " << cancels[i] << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leal (%rcx,%rcx,2), %eax
incl %eax
movq %rax, -0x40(%rbp)
xorl %r12d, %r12d
movq 0x56b4(%rip), %r13      # 0x6fd8
leaq 0x2706(%rip), %rbx      # 0x4031
cmpq -0x40(%rbp), %r12
je 0x1a35
movq %r13, %rdi
leaq 0x274a(%rip), %rsi      # 0x4089
callq 0x1100
movq %rax, %rdi
movq %r12, %rsi
callq 0x10c0
movq %rax, %rdi
leaq 0x272c(%rip), %rsi      # 0x4085
callq 0x1100
movq -0x30(%rbp), %r15
movq (%r15), %rcx
movl (%rcx,%r12,4), %esi
movq %rax, %rdi
callq 0x11d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1100
movq (%r15), %rcx
movl (%rcx,%r12,4), %esi
movq %rax, %rdi
callq 0x11d0
movq %rax, %rdi
leaq 0x26f7(%rip), %rsi      # 0x408c
callq 0x1100
xorl %eax, %eax
movq %r12, -0x48(%rbp)
imulq $0x18, %r12, %r12
movl %eax, %r15d
movq (%r14), %rcx
movq (%rcx,%r12), %rax
movq 0x8(%rcx,%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x19ff
movl 0x4(%rax,%r15,8), %esi
movq %r13, %rdi
callq 0x11d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1100
movq (%r14), %rcx
movq (%rcx,%r12), %rcx
movl (%rcx,%r15,8), %esi
movq %rax, %rdi
callq 0x11d0
movq %rax, %rdi
leaq 0x269d(%rip), %rsi      # 0x4091
callq 0x1100
leal 0x1(%r15), %eax
jmp 0x19a4
movq %r13, %rdi
leaq 0x268b(%rip), %rsi      # 0x4094
callq 0x1100
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq -0x48(%rbp), %r12
movl (%rcx,%r12,4), %esi
movq %rax, %rdi
callq 0x11d0
movq %rax, %rdi
callq 0x1090
incq %r12
jmp 0x192b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq