LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/db.cpp
// Function: db::QueryFilter(int, int, std::vector<unsigned long, std::allocator<unsigned long>>*, char**)
inline bool db::QueryFilter( int i, int bf_no, vector<uint64_t>* hash_digests, char** bf_list)
{
	bool result = true;
	int tmp_filter_size = filter_size;
	int tmp_num_lines = num_lines;
/*	
	if(i == num_levels - 1 && bf_no == num_sstPerLevel[i]-1){
		tmp_filter_size = last_filter_size;
	}
*/	
	if(i == num_levels - 1 && bf_no == num_sstPerLevel[i]-1){
		tmp_num_lines = last_num_lines;
	}


	if(fastlocal_bf){
		for(int blo = 0; blo < num_filter_units; blo++){
			if(!FastLocalBF::MayMatch(hash_digests->at(blo), tmp_filter_size, num_probes, bf_list[blo])) return false;
		}
	}else{
		for(int blo = 0; blo < num_filter_units; blo++){
			if(!LegacyBF::MayMatch(hash_digests->at(blo), tmp_num_lines, num_probes, bf_list[blo])) return false;
		}
	}
	

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movl 0xdc(%rdi), %eax
movl 0x128(%rdi), %r12d
decl %eax
cmpl %esi, %eax
jne 0xc765
movslq %esi, %rax
movq 0xe8(%r15), %rcx
movl (%rcx,%rax,4), %eax
decl %eax
cmpl %edx, %eax
jne 0xc765
movl 0x12c(%r15), %r12d
cmpb $0x0, 0x10c(%r15)
je 0xc7b3
movl 0x120(%r15), %r12d
xorl %r13d, %r13d
movslq 0x110(%r15), %rax
cmpq %rax, %r13
setge %bpl
jge 0xc7ee
movq %r14, %rdi
movq %r13, %rsi
callq 0xb6d8
movq (%rax), %rdi
movl 0x130(%r15), %edx
movq (%rbx,%r13,8), %rcx
movl %r12d, %esi
callq 0xcb2c
incq %r13
testb %al, %al
jne 0xc779
jmp 0xc7ee
xorl %r13d, %r13d
movslq 0x110(%r15), %rax
cmpq %rax, %r13
setge %bpl
jge 0xc7ee
movq %r14, %rdi
movq %r13, %rsi
callq 0xb6d8
movq (%rax), %rdi
movl 0x130(%r15), %edx
movq (%rbx,%r13,8), %rcx
movl %r12d, %esi
callq 0xcb58
incq %r13
testb %al, %al
jne 0xc7b6
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: FastLocalBF::MayMatch(unsigned long, int, int, char const*)
static inline void PrepareHash(uint32_t h1, uint32_t len_bytes,
                                 const char *data,
                                 uint32_t /*out*/ *byte_offset) {
    uint32_t bytes_to_cache_line = fastrange32(len_bytes >> 6,h1) << 6;
    PREFETCH(data + bytes_to_cache_line, 0 /* rw */, 1 /* locality */);
    PREFETCH(data + bytes_to_cache_line + 63, 0 /* rw */, 1 /* locality */);
    *byte_offset = bytes_to_cache_line;
  }

// Assembly:
shrl $0x6, %esi
movl %edi, %eax
imulq %rax, %rsi
shrq $0x1a, %rsi
andl $-0x40, %esi
leaq (%rcx,%rsi), %rax
prefetcht2 (%rcx,%rsi)
prefetcht2 0x3f(%rcx,%rsi)
shrq $0x20, %rdi
movl %edx, %esi
movq %rax, %rdx
jmp 0xcb80
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./LegacyBF.h
// Function: LegacyBF::MayMatch(unsigned long, int, int, char*)
static bool MayMatch(uint64_t hash_digest, int num_lines, int num_probes, char* data) {  // originally BloomHash is used, to make it compatible with sharing hashing, change it with GetSliceHash64
    uint32_t hash = Lower32of64(hash_digest);
    //std::cout << Lower32of64(hash_digest) << std::endl;
    //std::cout << hash << std::endl;
    uint32_t byte_offset;
    LegacyBloomImpl::PrepareHashMayMatch(
        hash, num_lines, data, /*out*/ &byte_offset, 6);
    return LegacyBloomImpl::HashMayMatchPrepared(
        hash, num_probes, data + byte_offset, 6);
  }

// Assembly:
movl %edx, %r8d
movl %edi, %eax
xorl %edx, %edx
divl %esi
shll $0x6, %edx
leaq (%rcx,%rdx), %rax
prefetcht2 (%rcx,%rdx)
prefetcht2 0x3f(%rcx,%rdx)
pushq $0x6
popq %rcx
movl %r8d, %esi
movq %rax, %rdx
jmp 0xcbbe
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: LegacyLocalityBloomImpl<false>::HashMayMatchPrepared(unsigned int, int, char const*, int)
static inline bool HashMayMatchPrepared(uint32_t h, int num_probes,
                                          const char *data_at_offset,
                                          int log2_cache_line_bytes) {
    const int log2_cache_line_bits = log2_cache_line_bytes + 3;

    const uint32_t delta = (h >> 17) | (h << 15);
    for (int i = 0; i < num_probes; ++i) {
      // Mask to bit-within-cache-line address
      const uint32_t bitpos = h & ((1 << log2_cache_line_bits) - 1);
      if (((data_at_offset[bitpos / 8]) & (1 << (bitpos % 8))) == 0) {
        return false;
      }
      if (ExtraRotates) {
        h = (h >> log2_cache_line_bits) | (h << (32 - log2_cache_line_bits));
      }
      h += delta;
    }
    return true;
  }

// Assembly:
movl %edi, %eax
addb $0x3, %cl
pushq $-0x1
popq %r8
shll %cl, %r8d
roll $0xf, %eax
notl %r8d
xorl %ecx, %ecx
testl %esi, %esi
movl $0x0, %r9d
cmovgl %esi, %r9d
cmpl %ecx, %r9d
je 0xcc05
movl %edi, %r10d
andl %r8d, %r10d
movl %r10d, %r11d
shrl $0x3, %r11d
movzbl (%rdx,%r11), %r11d
andl $0x7, %r10d
btl %r10d, %r11d
jae 0xcc05
addl %eax, %edi
incl %ecx
jmp 0xcbde
cmpl %esi, %ecx
setge %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/db.cpp
// Function: db::binary_search(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char**, int)
inline int db::binary_search(string key, char** indexes, int size)
{
	int len = size;
	if(len == 0){return -1;}
	if(len == 1){return 0;}
	int start = 0;
	int end = len - 1;
	int mid;

	//for (int i=0 ; i<len ; i++){
	//	cout << fence_pointer[i] << endl;;
	//}

	if(strcmp(key.c_str(), indexes[start]) < 0){ return -1;}
	if(strcmp(key.c_str(), indexes[end]) > 0){ return -1;}

	while(end - start > 1){
		mid = (start + end)/2;
		if(strcmp(key.c_str(), indexes[mid])< 0){
			end = mid;
		} 
		else if(strcmp(key.c_str(), indexes[mid])  == 0){
			return mid;
		}
		else{
			start = mid;
		}
	}
	return start;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbp
testl %ecx, %ecx
je 0xcc91
movl %ecx, %r14d
cmpl $0x1, %ecx
jne 0xcc2a
xorl %ebp, %ebp
jmp 0xcc91
movq %rdx, %rbx
movq (%rsi), %r15
movq (%rdx), %rsi
movq %r15, %rdi
callq 0x6580
testl %eax, %eax
js 0xcc91
movslq %r14d, %rax
movq -0x8(%rbx,%rax,8), %rsi
movq %r15, %rdi
callq 0x6580
testl %eax, %eax
jg 0xcc91
decl %r14d
xorl %r12d, %r12d
leal 0x1(%r12), %r13d
movl %r14d, %ebp
cmpl %r13d, %ebp
jle 0xcc8e
movl %ebp, %r14d
leal (%r14,%r12), %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
movl %eax, %ebp
cltq
movq (%rbx,%rax,8), %rsi
movq %r15, %rdi
callq 0x6580
testl %eax, %eax
js 0xcc61
movl %ebp, %r12d
jne 0xcc59
jmp 0xcc91
movl %r12d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: BloomMath::CacheLocalFpRate(double, int, int)
static double CacheLocalFpRate(double bits_per_key, int num_probes,
                                 int cache_line_bits) {
    double keys_per_cache_line = cache_line_bits / bits_per_key;
    // A reasonable estimate is the average of the FP rates for one standard
    // deviation above and below the mean bucket occupancy. See
    // https://github.com/facebook/rocksdb/wiki/RocksDB-Bloom-Filter#the-math
    double keys_stddev = std::sqrt(keys_per_cache_line);
    double crowded_fp = StandardFpRate(
        cache_line_bits / (keys_per_cache_line + keys_stddev), num_probes);
    double uncrowded_fp = StandardFpRate(
        cache_line_bits / (keys_per_cache_line - keys_stddev), num_probes);
    return (crowded_fp + uncrowded_fp) / 2;
  }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
cvtsi2sd %esi, %xmm1
movsd %xmm1, 0x8(%rsp)
divsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movsd %xmm1, (%rsp)
jb 0xd37a
sqrtsd %xmm1, %xmm0
jmp 0xd388
movapd %xmm1, %xmm0
callq 0x6330
movsd (%rsp), %xmm1
movsd %xmm0, 0x10(%rsp)
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
movl %ebx, %edi
callq 0xd454
movsd %xmm0, 0x18(%rsp)
movsd (%rsp), %xmm1
subsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
movl %ebx, %edi
callq 0xd454
addsd 0x18(%rsp), %xmm0
mulsd 0x14d15(%rip), %xmm0    # 0x220e8
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: BloomMath::FingerprintFpRate(unsigned long, int)
static double FingerprintFpRate(size_t num_keys, int fingerprint_bits) {
    double inv_fingerprint_space = std::pow(0.5, fingerprint_bits);
    // Base estimate assumes each key maps to a unique fingerprint.
    // Could be > 1 in extreme cases.
    double base_estimate = num_keys * inv_fingerprint_space;
    // To account for potential overlap, we choose between two formulas
    if (base_estimate > 0.0001) {
      // A very good formula assuming we don't construct a floating point
      // number extremely close to 1. Always produces a probability < 1.
      return 1.0 - std::exp(-base_estimate);
    } else {
      // A very good formula when base_estimate is far below 1. (Subtract
      // away the integral-approximated sum that some key has same hash as
      // one coming before it in a list.)
      return base_estimate - (base_estimate * base_estimate * 0.5);
    }
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cvtsi2sd %esi, %xmm0
xorpd 0x14d56(%rip), %xmm0    # 0x22140
callq 0x63c0
movq %rbx, %xmm2
punpckldq 0x14d14(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x14d1c(%rip), %xmm2    # 0x22120
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movapd 0x14d24(%rip), %xmm0    # 0x22140
ucomisd 0x14ce4(%rip), %xmm1    # 0x22108
xorpd %xmm1, %xmm0
jbe 0xd441
callq 0x66c0
movsd 0x14cc9(%rip), %xmm1    # 0x22100
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rbx
retq
mulsd %xmm1, %xmm0
mulsd 0x14c9b(%rip), %xmm0    # 0x220e8
addsd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/BF_bit.cpp
// Function: BFHash::prepareHashFuncs(HashType)
void BFHash:: prepareHashFuncs(HashType ht){
   ht_ = ht;
   filter_unit_hash_funcs_ = vector<HashType> (num_filter_units_,  ht);
   hash_digests_ = new vector<uint64_t> (num_filter_units_, 0);
   filter_unit_seeds_ = vector<uint32_t> (1, 0xbc9f1d34);
   uint32_t last_seed = 0xbc9f1d34;
   for(int i = 1; i < num_filter_units_; i++){
      last_seed = (last_seed << 17 | last_seed >> 15) + last_seed;
      filter_unit_seeds_.push_back(last_seed);
   }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x14(%rsp), %rdx
movl %edi, (%rdx)
movl %edi, 0x26957(%rip)     # 0x353ec
movslq 0x26944(%rip), %rsi     # 0x353e0
leaq 0x18(%rsp), %r14
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
callq 0xef00
leaq 0x269c3(%rip), %rdi     # 0x35478
movq %r14, %rsi
callq 0xf08e
movq %r14, %rdi
callq 0xefca
pushq $0x18
popq %rdi
callq 0x6420
movq %rax, %rbx
movslq 0x26909(%rip), %rsi     # 0x353e0
andq $0x0, (%r14)
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rax, %rdi
callq 0xb326
movq %rbx, 0x269b4(%rip)     # 0x354a8
movl $0xbc9f1d34, %ebp       # imm = 0xBC9F1D34
leaq 0x10(%rsp), %rdx
movl %ebp, (%rdx)
leaq 0x18(%rsp), %rbx
pushq $0x1
popq %rsi
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
callq 0xef56
leaq 0x26974(%rip), %r14     # 0x35490
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf158
movq %rbx, %rdi
callq 0xc250
movl %ebp, (%rbx)
pushq $0x1
popq %rbp
cmpl 0x268a6(%rip), %ebp     # 0x353e0
jge 0xeb5a
movl 0x18(%rsp), %eax
movl %eax, %ecx
roll $0x11, %ecx
addl %eax, %ecx
movl %ecx, 0x18(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xefac
incl %ebp
jmp 0xeb34
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x63f0
movq %r14, %rdi
callq 0x66b0
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/BF_bit.cpp
// Function: BFHash::get_hash_digest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, HashType, unsigned int)
uint64_t BFHash::get_hash_digest(string & key, HashType ht, uint32_t seed){
    uint64_t result = 0;
    switch(ht){
        case MD5:
            memcpy(&result, md5(key).c_str(), sizeof(result));
            break;
        case SHA2:{
            uint8_t hash[32];
            const uint8_t * a = (const uint8_t*)key.c_str();
            calc_sha_256(hash, a, key.length());
	    for(int i = 0; i < 32; i++){
               result = (result << 1) + (hash[i]&0x1);
	    }
            break;
        }
            
        case MurMurhash: {
            result = MurmurHash2(key.c_str(), key.size(), seed);
            break;
	}
	case MurMur64: {
	    result = MurmurHash64A( key.c_str(), key.size(), seed);
	    break;
	}
        case XXhash:
        {
            // result = MurmurHash2(key.c_str(), key.size(), seed);
            XXH64_hash_t const p = seed;
            const void * key_void = key.c_str();
            XXH64_hash_t const h = XXH64(key_void, key.size(), p);
            result = h;
            break;
        }
        case CRC:{
            const void * key_void = key.c_str();
            result = crc32_fast( key_void, (unsigned long)key.size(), seed );
            break;
        }
        case CITY:{
            const char * key_void = key.c_str();
            result = CityHash64WithSeed( key_void, (unsigned long)key.size(), (unsigned long) seed);
	    break;
        }
	default:
            result = MurmurHash2(key.c_str(), key.size(), seed);
            break;
    }
    
    return result;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rax
cmpl $0x6, %esi
ja 0xebe6
movl %esi, %ecx
leaq 0x13b14(%rip), %rsi     # 0x226bc
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6570
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x1d658
movq %rsp, %rdi
movq (%rdi), %rax
movq (%rax), %rbx
callq 0x61f0
leaq 0x20(%rsp), %rdi
callq 0x61f0
jmp 0xec4d
movq (%rax), %rdi
movl 0x8(%rax), %esi
callq 0x1d760
jmp 0xec4b
movl %edx, %edx
movq (%rax), %rdi
movq 0x8(%rax), %rsi
addq $0x40, %rsp
popq %rbx
jmp 0x1df83
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rsp, %rdi
callq 0x1d838
xorl %eax, %eax
xorl %ebx, %ebx
cmpq $0x20, %rax
je 0xec4d
movzbl (%rsp,%rax), %ecx
andl $0x1, %ecx
leaq (%rcx,%rbx,2), %rbx
incq %rax
jmp 0xec19
movq (%rax), %rdi
movl 0x8(%rax), %esi
addq $0x40, %rsp
popq %rbx
jmp 0x1d688
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x21285
movl %eax, %ebx
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movl %edx, %edx
addq $0x40, %rsp
popq %rbx
jmp 0x21ad9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x61f0
movq %rbx, %rdi
callq 0x66b0
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/BF_bit.cpp
// Function: get_index(unsigned long, int, int, int*)
void get_index( uint64_t hash_digest, int BF_index, int BF_size, int *index )
{

  uint64_t m_int_hash = hash_digest;
  index[0] = m_int_hash % BF_size;
  // get BF indices
  uint64_t delta = (m_int_hash << 17 | m_int_hash >> 15);
  for( uint32_t n=1 ; n<BF_index ; n++ ){
    m_int_hash = m_int_hash + delta; 
    index[n] =  m_int_hash % BF_size;
  }

  return;
}

// Assembly:
movslq %edx, %r8
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl %edx, (%rcx)
movq %rdi, %rax
shlq $0x11, %rax
movq %rdi, %r9
shrq $0xf, %r9
orq %rax, %r9
movl %esi, %esi
addq %r9, %rdi
pushq $0x1
popq %r10
cmpq %rsi, %r10
jae 0xeed5
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl %edx, (%rcx,%r10,4)
incq %r10
addq %r9, %rdi
jmp 0xeebc
retq
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::ArgumentParser::ArgumentParser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ArgumentParser(const std::string &description_, const std::string &epilog_ = std::string())
            {
                Description(description_);
                Epilog(epilog_);
                LongPrefix("--");
                ShortPrefix("-");
                LongSeparator("=");
                Terminator("--");
                SetArgumentSeparations(true, true, true, true);
                matched = true;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x11d26
leaq 0x22bab(%rip), %rax     # 0x343e0
movq %rax, (%rbx)
leaq 0x188(%rbx), %rax
movq %rax, 0x178(%rbx)
andq $0x0, 0x180(%rbx)
xorl %eax, %eax
movb %al, 0x188(%rbx)
leaq 0x1a8(%rbx), %rcx
movq %rcx, 0x198(%rbx)
andq $0x0, 0x1a0(%rbx)
movb %al, 0x1a8(%rbx)
leaq 0x1c8(%rbx), %rcx
movq %rcx, 0x1b8(%rbx)
andq $0x0, 0x1c0(%rbx)
movb %al, 0x1c8(%rbx)
leaq 0x1e8(%rbx), %rcx
movq %rcx, 0x1d8(%rbx)
andq $0x0, 0x1e0(%rbx)
movb %al, 0x1e8(%rbx)
movl $0x1010101, 0x1f8(%rbx) # imm = 0x1010101
andq $0x0, 0x200(%rbx)
leaq 0x1d8(%rbx), %r14
movb %al, 0x208(%rbx)
leaq 0x210(%rbx), %r15
movq %r15, %rdi
callq 0x11e70
leaq 0xa8(%rbx), %rdi
movq %r13, %rsi
callq 0x6250
leaq 0xc8(%rbx), %rdi
movq %r12, %rsi
callq 0x6250
leaq 0x11444(%rip), %rsi     # 0x22d41
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x61b0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12214
leaq 0x8(%rsp), %rdi
callq 0x61f0
leaq 0x11418(%rip), %rsi     # 0x22d42
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x61b0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12244
leaq 0x8(%rsp), %rdi
callq 0x61f0
leaq 0x106dc(%rip), %rsi     # 0x22033
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x61b0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12274
leaq 0x8(%rsp), %rdi
callq 0x61f0
leaq 0x113bd(%rip), %rsi     # 0x22d41
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x61b0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6250
leaq 0x8(%rsp), %rdi
callq 0x61f0
pushq $0x1
popq %rcx
movq %rbx, %rdi
movl %ecx, %esi
movl %ecx, %edx
movl %ecx, %r8d
callq 0x12370
movb $0x1, 0xc(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x119db
jmp 0x119f1
jmp 0x119db
jmp 0x119f1
jmp 0x119db
jmp 0x119f1
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x61f0
jmp 0x119f4
jmp 0x119f1
movq %rax, %r12
jmp 0x119fc
movq %rax, %r12
movq %r15, %rdi
callq 0x12416
leaq 0x178(%rbx), %r15
leaq 0x198(%rbx), %r13
leaq 0x1b8(%rbx), %rbp
movq %r14, %rdi
callq 0x61f0
movq %rbp, %rdi
callq 0x61f0
movq %r13, %rdi
callq 0x61f0
movq %r15, %rdi
callq 0x61f0
movq %rbx, %rdi
callq 0x12de0
movq %r12, %rdi
callq 0x66b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::ArgumentParser::ParseCLI(int, char const* const*)
bool ParseCLI(const int argc, const char * const * argv)
            {
                if (Prog().empty())
                {
                    Prog(argv[0]);
                }
                const std::vector<std::string> args(argv + 1, argv + argc);
                return ParseArgs(args) == std::end(args);
            }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x2c0(%rdi)
jne 0x11bcf
movq (%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x61b0
leaq 0x2b8(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6250
leaq 0x10(%rsp), %rdi
callq 0x61f0
movslq %ebp, %rax
leaq (%r14,%rax,8), %rdx
addq $0x8, %r14
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movq %r14, %rsi
callq 0x17cec
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x17d1e
leaq 0x10(%rsp), %rdi
cmpq 0x8(%rdi), %rax
sete %bl
callq 0x739e
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x61f0
jmp 0x11c38
jmp 0x11c35
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x739e
jmp 0x11c38
movq %rax, %rbx
movq %rbx, %rdi
callq 0x66b0
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Command::Command()
inline std::vector<std::string> Wrap(const std::string &in, const std::string::size_type width, std::string::size_type firstlinewidth = 0)
    {
        // Preserve existing line breaks
        const auto newlineloc = in.find('\n');
        if (newlineloc != in.npos)
        {
            auto first = Wrap(std::string(in, 0, newlineloc), width);
            auto second = Wrap(std::string(in, newlineloc + 1), width);
            first.insert(
                std::end(first),
                std::make_move_iterator(std::begin(second)),
                std::make_move_iterator(std::end(second)));
            return first;
        }

        std::istringstream stream(in);
        std::string::size_type indent = 0;

        for (char c : in)
        {
            if (!isspace(c))
            {
                break;
            }
            ++indent;
        }

        return Wrap(std::istream_iterator<std::string>(stream), std::istream_iterator<std::string>(),
                    width, firstlinewidth, indent);
    }

// Assembly:
pushq %rbx
subq $0x40, %rsp
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x20(%rsp), %rdx
andq $0x0, 0x8(%rdx)
movq %rdi, %rbx
movb $0x0, (%rax)
leaq -0x30e(%rip), %rax      # 0x11a42
movq %rax, (%rdx)
leaq 0xaa4c(%rip), %rax      # 0x1c7a6
movq %rax, 0x18(%rdx)
leaq 0xaa49(%rip), %rax      # 0x1c7ae
movq %rax, 0x10(%rdx)
movq %rsp, %rsi
xorl %ecx, %ecx
callq 0x12d86
leaq 0x20(%rsp), %rdi
callq 0x11ac8
movq %rsp, %rdi
callq 0x61f0
leaq 0x22734(%rip), %rax     # 0x344c0
movq %rax, (%rbx)
leaq 0x78(%rbx), %rax
movq %rax, 0x68(%rbx)
andq $0x0, 0x70(%rbx)
xorl %eax, %eax
movb %al, 0x78(%rbx)
leaq 0x98(%rbx), %rcx
movq %rcx, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
movb %al, 0x98(%rbx)
leaq 0xb8(%rbx), %rcx
movq %rcx, 0xa8(%rbx)
andq $0x0, 0xb0(%rbx)
movb %al, 0xb8(%rbx)
leaq 0xd8(%rbx), %rcx
movq %rcx, 0xc8(%rbx)
andq $0x0, 0xd0(%rbx)
movb %al, 0xd8(%rbx)
leaq 0xf8(%rbx), %rcx
movq %rcx, 0xe8(%rbx)
andq $0x0, 0xf0(%rbx)
movb %al, 0xf8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x108(%rbx)
movups %xmm0, 0x118(%rbx)
movb $0x1, 0x128(%rbx)
andq $0x0, 0x170(%rbx)
movups %xmm0, 0x15b(%rbx)
movups %xmm0, 0x150(%rbx)
movups %xmm0, 0x140(%rbx)
movups %xmm0, 0x130(%rbx)
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x11ac8
movq %rsp, %rdi
callq 0x61f0
movq %rbx, %rdi
callq 0x66b0
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::ArgumentParser::SetArgumentSeparations(bool, bool, bool, bool)
void SetArgumentSeparations(
                const bool allowJoinedShortValue_,
                const bool allowJoinedLongValue_,
                const bool allowSeparateShortValue_,
                const bool allowSeparateLongValue_)
            {
                this->allowJoinedShortValue = allowJoinedShortValue_;
                this->allowJoinedLongValue = allowJoinedLongValue_;
                this->allowSeparateShortValue = allowSeparateShortValue_;
                this->allowSeparateLongValue = allowSeparateLongValue_;

                this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
                this->helpParams.shortSeparator = allowJoinedShortValue ? "" : " ";
            }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movb %sil, 0x1f8(%rdi)
movb %bpl, 0x1f9(%rdi)
movb %cl, 0x1fa(%rdi)
movb %r8b, 0x1fb(%rdi)
testl %edx, %edx
je 0x123af
leaq 0x1b8(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x6570
jmp 0x123c5
leaq 0x10a5e(%rip), %rsi     # 0x22e14
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x61b0
leaq 0x298(%rbx), %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x64c0
movq %r14, %rdi
callq 0x61f0
testb %bpl, %bpl
leaq 0xffee(%rip), %rax      # 0x223d9
cmpb $0x0, 0x1f8(%rbx)
leaq 0x10a1b(%rip), %rsi     # 0x22e14
cmovneq %rax, %rsi
addq $0x278, %rbx            # imm = 0x278
movq %rbx, %rdi
callq 0x6720
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Command::GetCommands()
virtual std::vector<Command*> GetCommands() override
            {
                if (selectedCommand != nullptr)
                {
                    return selectedCommand->GetCommands();
                }

                if (Matched())
                {
                    return Group::GetCommands();
                }

                return { this };
            }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x130(%rsi), %rsi
testq %rsi, %rsi
je 0x12a5e
movq (%rsi), %rax
movq %rbx, %rdi
callq *0x28(%rax)
jmp 0x12a90
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x12a78
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1303a
jmp 0x12a90
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
pushq $0x1
popq %rdx
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
callq 0x155f8
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Command::Match(args::EitherFlag const&)
virtual FlagBase *Match(const EitherFlag &flag) override
            {
                if (selectedCommand != nullptr)
                {
                    if (auto *res = selectedCommand->Match(flag))
                    {
                        return res;
                    }

                    for (auto *child: Children())
                    {
                        if ((child->GetOptions() & Options::Global) != Options::None)
                        {
                            if (auto *res = child->Match(flag))
                            {
                                return res;
                            }
                        }
                    }

                    return nullptr;
                }

                if (subparser != nullptr)
                {
                    return subparser->Match(flag);
                }

                return Matched() ? Group::Match(flag) : nullptr;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x130(%rdi), %rdi
testq %rdi, %rdi
je 0x12ada
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
testq %rax, %rax
je 0x12afd
movq %rax, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x170(%r15), %rdi
testq %rdi, %rdi
je 0x12b2b
movq (%rdi), %rax
movq 0x38(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movq 0x30(%r15), %r12
movq 0x38(%r15), %r15
xorl %r14d, %r14d
cmpq %r15, %r12
je 0x12acb
movq (%r12), %rdi
testb $0x10, 0x8(%rdi)
je 0x12b25
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
testq %rax, %rax
jne 0x12ac8
addq $0x8, %r12
jmp 0x12b08
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x12b4e
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x130c6
xorl %r14d, %r14d
jmp 0x12acb
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Command::GetNextPositional()
virtual PositionalBase *GetNextPositional() override
            {
                if (selectedCommand != nullptr)
                {
                    if (auto *res = selectedCommand->GetNextPositional())
                    {
                        return res;
                    }

                    for (auto *child: Children())
                    {
                        if ((child->GetOptions() & Options::Global) != Options::None)
                        {
                            if (auto *res = child->GetNextPositional())
                            {
                                return res;
                            }
                        }
                    }

                    return nullptr;
                }

                if (subparser != nullptr)
                {
                    return subparser->GetNextPositional();
                }

                return Matched() ? Group::GetNextPositional() : nullptr;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x130(%rdi), %rdi
testq %rdi, %rdi
je 0x12b81
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
je 0x12b98
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x170(%r14), %rdi
testq %rdi, %rdi
je 0x12bc1
movq (%rdi), %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x40(%rax)
movq 0x30(%r14), %r15
movq 0x38(%r14), %r14
xorl %ebx, %ebx
cmpq %r14, %r15
je 0x12b78
movq (%r15), %rdi
testb $0x10, 0x8(%rdi)
je 0x12bbb
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
jne 0x12b75
addq $0x8, %r15
jmp 0x12ba2
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x12bdb
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x13108
xorl %ebx, %ebx
jmp 0x12b78
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Command::GetAllFlags()
virtual std::vector<FlagBase*> GetAllFlags() override
            {
                std::vector<FlagBase*> res;

                if (!Matched())
                {
                    return res;
                }

                for (auto *child: Children())
                {
                    if (selectedCommand == nullptr || (child->GetOptions() & Options::Global) != Options::None)
                    {
                        auto childFlags = child->GetAllFlags();
                        res.insert(res.end(), childFlags.begin(), childFlags.end());
                    }
                }

                if (selectedCommand != nullptr)
                {
                    auto childFlags = selectedCommand->GetAllFlags();
                    res.insert(res.end(), childFlags.begin(), childFlags.end());
                }

                if (subparser != nullptr)
                {
                    auto childFlags = subparser->GetAllFlags();
                    res.insert(res.end(), childFlags.begin(), childFlags.end());
                }

                return res;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x12cd0
movq 0x30(%r14), %r12
movq 0x38(%r14), %r13
leaq 0x8(%rsp), %r15
cmpq %r13, %r12
je 0x12c62
movq (%r12), %rsi
cmpq $0x0, 0x130(%r14)
je 0x12c35
testb $0x10, 0x8(%rsi)
je 0x12c5c
movq (%rsi), %rax
movq %r15, %rdi
callq *0x48(%rax)
movq 0x8(%rbx), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x13e4e
movq %r15, %rdi
callq 0x14094
addq $0x8, %r12
jmp 0x12c1c
movq 0x130(%r14), %rsi
testq %rsi, %rsi
je 0x12c99
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x48(%rax)
movq 0x8(%rbx), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x13e4e
leaq 0x8(%rsp), %rdi
callq 0x14094
movq 0x170(%r14), %rsi
testq %rsi, %rsi
je 0x12cd0
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x48(%rax)
movq 0x8(%rbx), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x13e4e
leaq 0x8(%rsp), %rdi
callq 0x14094
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x12cee
jmp 0x12ce9
jmp 0x12cee
jmp 0x12ce9
movq %rax, %r14
jmp 0x12cfb
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x14094
movq %rbx, %rdi
callq 0x14094
movq %r14, %rdi
callq 0x66b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Command::Reset()
virtual void Reset() noexcept override
            {
                Group::Reset();
                selectedCommand = nullptr;
                subparserProgramLine.clear();
                subparserDescription.clear();
                subparserHasFlag = false;
                subparserHasPositional = false;
                subparserHasCommand = false;
#ifdef ARGS_NOEXCEPT
                subparserError = Error::None;
#endif
            }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x13290
andq $0x0, 0x130(%rbx)
leaq 0x150(%rbx), %rdi
callq 0xbe20
leaq 0x138(%rbx), %rdi
callq 0x145ce
andw $0x0, 0x168(%rbx)
movb $0x0, 0x16a(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Group::GetDescription[abi:cxx11](args::HelpParams const&, unsigned int) const
virtual std::vector<std::tuple<std::string, std::string, unsigned>> GetDescription(const HelpParams &params, const unsigned int indent) const override
            {
                std::vector<std::tuple<std::string, std::string, unsigned int>> descriptions;

                // Push that group description on the back if not empty
                unsigned addindent = 0;
                if (!help.empty())
                {
                    descriptions.emplace_back(help, "", indent);
                    addindent = 1;
                }

                for (Base *child: Children())
                {
                    if ((child->GetOptions() & Options::HiddenFromDescription) != Options::None)
                    {
                        continue;
                    }

                    auto groupDescriptions = child->GetDescription(params, indent + addindent);
                    descriptions.insert(
                        std::end(descriptions),
                        std::make_move_iterator(std::begin(groupDescriptions)),
                        std::make_move_iterator(std::end(groupDescriptions)));
                }
                return descriptions;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, 0xc(%rsp)
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpq $0x0, 0x18(%rsi)
je 0x12fb0
leaq 0x10(%r15), %rsi
leaq 0xf43b(%rip), %rdx      # 0x223d9
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
callq 0x13658
pushq $0x1
popq %rbp
jmp 0x12fb2
xorl %ebp, %ebp
movq 0x30(%r15), %r12
movq 0x38(%r15), %r13
leaq 0x10(%rsp), %r15
cmpq %r13, %r12
je 0x13004
movq (%r12), %rsi
testb $0x8, 0x8(%rsi)
jne 0x12ffe
movl 0xc(%rsp), %ecx
addl %ebp, %ecx
movq (%rsi), %rax
movq %r15, %rdi
movq %r14, %rdx
callq *0x20(%rax)
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x13690
movq %r15, %rdi
callq 0x136b0
addq $0x8, %r12
jmp 0x12fbf
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13018
movq %rax, %r14
jmp 0x1302a
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x136b0
movq %rbx, %rdi
callq 0x136b0
movq %r14, %rdi
callq 0x66b0
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Group::GetCommands()
virtual std::vector<Command*> GetCommands() override
            {
                std::vector<Command*> res;
                for (const auto &child : Children())
                {
                    auto subparsers = child->GetCommands();
                    res.insert(std::end(res), std::begin(subparsers), std::end(subparsers));
                }
                return res;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x30(%rsi), %r15
movq 0x38(%rsi), %r12
movq %rsp, %r14
cmpq %r12, %r15
je 0x13092
movq (%r15), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *0x28(%rax)
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x13bfa
movq %r14, %rdi
callq 0x13e40
addq $0x8, %r15
jmp 0x1305e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x130b1
movq %rax, %r14
movq %rsp, %rdi
callq 0x13e40
movq %rbx, %rdi
callq 0x13e40
movq %r14, %rdi
callq 0x66b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Group::Match(args::EitherFlag const&)
virtual FlagBase *Match(const EitherFlag &flag) override
            {
                for (Base *child: Children())
                {
                    if (FlagBase *match = child->Match(flag))
                    {
                        return match;
                    }
                }
                return nullptr;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x30(%rdi), %r15
movq 0x38(%rdi), %r12
xorl %ebx, %ebx
cmpq %r12, %r15
je 0x130f8
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x38(%rax)
addq $0x8, %r15
testq %rax, %rax
je 0x130db
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Group::GetNextPositional()
std::vector<std::string> MapKeysToStrings(const T &map)
        {
            std::vector<std::string> res;
            using K = typename std::decay<decltype(std::begin(map)->first)>::type;
            if (IsConvertableToString<K>::value)
            {
                for (const auto &p : map)
                {
                    res.push_back(detail::ToString(p.first));
                }

                std::sort(res.begin(), res.end());
            }
            return res;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x30(%rdi), %r14
movq 0x38(%rdi), %r15
xorl %ebx, %ebx
cmpq %r15, %r14
je 0x13131
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
addq $0x8, %r14
testq %rax, %rax
je 0x13117
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Group::GetAllFlags()
virtual std::vector<FlagBase*> GetAllFlags() override
            {
                std::vector<FlagBase*> res;
                for (Base *child: Children())
                {
                    auto childRes = child->GetAllFlags();
                    res.insert(res.end(), childRes.begin(), childRes.end());
                }
                return res;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x30(%rsi), %r15
movq 0x38(%rsi), %r12
movq %rsp, %r14
cmpq %r12, %r15
je 0x13192
movq (%r15), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *0x48(%rax)
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x13e4e
movq %r14, %rdi
callq 0x14094
addq $0x8, %r15
jmp 0x1315e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x131b1
movq %rax, %r14
movq %rsp, %rdi
callq 0x14094
movq %rbx, %rdi
callq 0x14094
movq %r14, %rdi
callq 0x66b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Group::GetProgramLine[abi:cxx11](args::HelpParams const&) const
virtual std::vector<std::string> GetProgramLine(const HelpParams &params) const override
            {
                std::vector <std::string> names;
                for (Base *child: Children())
                {
                    if ((child->GetOptions() & Options::HiddenFromUsage) != Options::None)
                    {
                        continue;
                    }

                    auto groupNames = child->GetProgramLine(params);
                    names.insert(
                        std::end(names),
                        std::make_move_iterator(std::begin(groupNames)),
                        std::make_move_iterator(std::end(groupNames)));
                }
                return names;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x30(%rsi), %r12
movq 0x38(%rsi), %r13
leaq 0x8(%rsp), %r15
cmpq %r13, %r12
je 0x1325c
movq (%r12), %rsi
testb $0x4, 0x8(%rsi)
jne 0x13256
movq (%rsi), %rax
movq %r15, %rdi
movq %r14, %rdx
callq *0x68(%rax)
movq 0x8(%rbx), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x1436c
movq %r15, %rdi
callq 0x739e
addq $0x8, %r12
jmp 0x1321d
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x1327f
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x739e
movq %rbx, %rdi
callq 0x739e
movq %r14, %rdi
callq 0x66b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Group::Reset()
virtual void Reset() noexcept
            {
                matched = false;
#ifdef ARGS_NOEXCEPT
                error = Error::None;
                errorMsg.clear();
#endif
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movb $0x0, 0xc(%rdi)
movq 0x30(%rdi), %rbx
movq 0x38(%rdi), %r14
cmpq %r14, %rbx
je 0x132b4
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
addq $0x8, %rbx
jmp 0x132a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Matcher::Matcher<std::__detail::_Node_iterator<char, true, false>, std::__detail::_Node_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, true, true>>(std::__detail::_Node_iterator<char, true, false>, std::__detail::_Node_iterator<char, true, false>, std::__detail::_Node_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, true, true>, std::__detail::_Node_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, true, true>)
Matcher(ShortIt shortFlagsStart, ShortIt shortFlagsEnd, LongIt longFlagsStart, LongIt longFlagsEnd) :
                shortFlags(shortFlagsStart, shortFlagsEnd),
                longFlags(longFlagsStart, longFlagsEnd)
            {
                if (shortFlags.empty() && longFlags.empty())
                {
#ifndef ARGS_NOEXCEPT
                    throw UsageError("empty Matcher");
#endif
                }
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdi, %rbx
leaq 0x17(%rsp), %r13
movq %r13, (%rsp)
leaq 0x18(%rsp), %r8
leaq 0x16(%rsp), %r9
xorl %ecx, %ecx
callq 0x161ec
leaq 0x38(%rbx), %r14
movq %r13, (%rsp)
leaq 0x18(%rsp), %r8
leaq 0x16(%rsp), %r9
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x162fe
movq 0x50(%rbx), %rax
orq 0x18(%rbx), %rax
je 0x16166
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x6220
movq %rax, %r15
leaq 0xcc78(%rip), %rsi      # 0x22df0
leaq 0x18(%rsp), %rdi
leaq 0x16(%rsp), %rdx
callq 0x61b0
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x14606
xorl %ebp, %ebp
leaq 0x1e4a8(%rip), %rsi     # 0x34648
movq 0x1ee19(%rip), %rdx     # 0x34fc0
movq %r15, %rdi
callq 0x6680
movq %rax, %r12
leaq 0x18(%rsp), %rdi
callq 0x61f0
testb %bpl, %bpl
jne 0x161c6
jmp 0x161ce
movq %rax, %r12
movq %r15, %rdi
callq 0x62f0
movq %r14, %rdi
callq 0x1641c
jmp 0x161db
movq %rax, %r12
movq %rbx, %rdi
callq 0x16438
movq %r12, %rdi
callq 0x66b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::FlagBase::Validate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
virtual void Validate(const std::string &shortPrefix, const std::string &longPrefix) const override
            {
                if (!Matched() && IsRequired())
                {
                        std::ostringstream problem;
                        problem << "Flag '" << matcher.GetLongOrAny().str(shortPrefix, longPrefix) << "' is required";
#ifdef ARGS_NOEXCEPT
                        error = Error::Required;
                        errorMsg = problem.str();
#else
                        throw RequiredError(problem.str());
#endif
                }
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x16521
testb $0x2, 0x8(%r15)
jne 0x16531
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x6560
leaq 0xc8b9(%rip), %rsi      # 0x22dfe
movq %r12, %rdi
callq 0x6410
movq %rax, %r12
addq $0xa0, %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x17234
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x17282
leaq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0x63b0
leaq 0xc87c(%rip), %rsi      # 0x22e05
movq %rax, %rdi
callq 0x6410
leaq 0x28(%rsp), %rdi
callq 0x61f0
leaq 0x8(%rsp), %rdi
callq 0x61f0
pushq $0x10
popq %rdi
callq 0x6220
movq %rax, %rbx
leaq 0x50(%rsp), %rsi
movq %rsp, %rdi
callq 0x6610
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x172fc
xorl %ebp, %ebp
leaq 0x1e444(%rip), %rsi     # 0x34a18
movq 0x1e9e5(%rip), %rdx     # 0x34fc0
movq %rbx, %rdi
callq 0x6680
movq %rax, %r14
movq %rsp, %rdi
callq 0x61f0
testb %bpl, %bpl
jne 0x165f8
jmp 0x16625
movq %rax, %r14
movq %rbx, %rdi
callq 0x62f0
jmp 0x16625
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x61f0
jmp 0x16614
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61f0
jmp 0x16625
jmp 0x16622
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x6100
movq %r14, %rdi
callq 0x66b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::FlagBase::Match(args::EitherFlag const&)
virtual FlagBase *Match(const EitherFlag &flag) override
            {
                if (matcher.Match(flag))
                {
                    if ((GetOptions() & Options::Single) != Options::None && matched)
                    {
                        std::ostringstream problem;
                        problem << "Flag '" << flag.str() << "' was passed multiple times, but is only allowed to be passed once";
#ifdef ARGS_NOEXCEPT
                        error = Error::Extra;
                        errorMsg = problem.str();
#else
                        throw ExtraError(problem.str());
#endif
                    }
                    matched = true;
                    return this;
                }
                return nullptr;
            }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %rbx
movq %rdi, %r14
addq $0xa0, %rdi
callq 0x1744a
testb %al, %al
je 0x1690a
testb $0x1, 0x8(%r14)
je 0x16903
cmpb $0x1, 0xc(%r14)
je 0x1691c
movb $0x1, 0xc(%r14)
jmp 0x1690d
xorl %r14d, %r14d
movq %r14, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x6560
leaq 0xc4ce(%rip), %rsi      # 0x22dfe
movq %r14, %rdi
callq 0x6410
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x17462
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x63b0
leaq 0xc4ba(%rip), %rsi      # 0x22e16
movq %rax, %rdi
callq 0x6410
leaq 0x8(%rsp), %rdi
callq 0x61f0
pushq $0x10
popq %rdi
callq 0x6220
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6610
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x17494
xorl %ebp, %ebp
leaq 0x1e0b7(%rip), %rsi     # 0x34a58
movq 0x1e618(%rip), %rdx     # 0x34fc0
movq %rbx, %rdi
callq 0x6680
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61f0
testb %bpl, %bpl
jne 0x169c7
jmp 0x169e5
movq %rax, %r14
movq %rbx, %rdi
callq 0x62f0
jmp 0x169e5
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61f0
jmp 0x169e5
jmp 0x169e2
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x6100
movq %r14, %rdi
callq 0x66b0
nop