LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/avx-turbo.cpp
// Function: aperf_ghz::mt_ratio()
double mt_ratio() {
        assert(state == STOPPED);
        assert(mperf_value != 0 && tsc_value != 0);
//        printf("timer ratio m: %lu (delta)\n", mperf_value);
//        printf("timer ratio a: %lu (delta)\n", aperf_value);
        return (double)mperf_value / tsc_value;
    }

// Assembly:
pushq %rax
cmpl $0x1, 0x20(%rdi)
jne 0x12328
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x12309
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x12309
movq %rcx, %xmm1
movq 0x8d82(%rip), %xmm2     # 0x1b050
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x8d86(%rip), %xmm3     # 0x1b060
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
popq %rax
retq
leaq 0xa681(%rip), %rdi      # 0x1c991
leaq 0x938b(%rip), %rsi      # 0x1b6a2
leaq 0xa656(%rip), %rcx      # 0x1c974
movl $0x13e, %edx            # imm = 0x13E
callq 0x6220
leaq 0xa4c7(%rip), %rdi      # 0x1c7f6
leaq 0x936c(%rip), %rsi      # 0x1b6a2
leaq 0xa637(%rip), %rcx      # 0x1c974
movl $0x13d, %edx            # imm = 0x13D
callq 0x6220
nop
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/avx-turbo.cpp
// Function: aperf_ghz::start()
virtual void start() override {
        assert(state == STOPPED);
        state = STARTED;
        mperf_value = mperf();
        aperf_value = aperf();
        tsc_value = rdtsc();
//        printf("started timer m: %lu\n", mperf_value);
//        printf("started timer a: %lu\n", aperf_value);
    }

// Assembly:
pushq %rbx
cmpl $0x1, 0x20(%rdi)
jne 0x12379
movq %rdi, %rbx
andl $0x0, 0x20(%rdi)
callq 0x123fc
movq %rax, 0x8(%rbx)
callq 0x12406
movq %rax, 0x10(%rbx)
rdtsc
shlq $0x20, %rdx
orq %rax, %rdx
movq %rdx, 0x18(%rbx)
popq %rbx
retq
leaq 0xa476(%rip), %rdi      # 0x1c7f6
leaq 0x931b(%rip), %rsi      # 0x1b6a2
leaq 0xa479(%rip), %rcx      # 0x1c807
movl $0x11f, %edx            # imm = 0x11F
callq 0x6220
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/avx-turbo.cpp
// Function: aperf_ghz::stop()
virtual void stop() override {
        assert(state == STARTED);
        mperf_value = mperf() - mperf_value;
        aperf_value = aperf() - aperf_value;
        tsc_value   = rdtsc() - tsc_value;
        state = STOPPED;
//        printf("stopped timer m: %lu (delta)\n", mperf_value);
//        printf("stopped timer a: %lu (delta)\n", aperf_value);
    }

// Assembly:
pushq %rbx
cmpl $0x0, 0x20(%rdi)
jne 0x123d6
movq %rdi, %rbx
callq 0x123fc
subq 0x8(%rbx), %rax
movq %rax, 0x8(%rbx)
callq 0x12406
subq 0x10(%rbx), %rax
movq %rax, 0x10(%rbx)
rdtsc
shlq $0x20, %rdx
orq %rax, %rdx
subq 0x18(%rbx), %rdx
movq %rdx, 0x18(%rbx)
movl $0x1, 0x20(%rbx)
popq %rbx
retq
leaq 0xa47d(%rip), %rdi      # 0x1c85a
leaq 0x92be(%rip), %rsi      # 0x1b6a2
leaq 0xa480(%rip), %rcx      # 0x1c86b
movl $0x129, %edx            # imm = 0x129
callq 0x6220
nop
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/avx-turbo.cpp
// Function: aperf_ghz::read(unsigned int)
static uint64_t read(uint32_t msr) {
        uint64_t value = -1;
        int res = read_msr_cur_cpu(msr, &value);
        assert(res == 0);
        return value;
    }

// Assembly:
pushq %rax
movq %rsp, %rsi
orq $-0x1, (%rsi)
callq 0x1406d
testl %eax, %eax
jne 0x12427
movq (%rsp), %rax
popq %rcx
retq
leaq 0xa3f9(%rip), %rdi      # 0x1c827
leaq 0x926d(%rip), %rsi      # 0x1b6a2
leaq 0xa3f4(%rip), %rcx      # 0x1c830
movl $0x111, %edx            # imm = 0x111
callq 0x6220
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/./stats.hpp
// Function: Stats::DescriptiveStats Stats::get_stats<unsigned long*>(unsigned long*, unsigned long*)
DescriptiveStats get_stats(iter_type first, iter_type last) {
	using dlimits = std::numeric_limits<double>;
	double min = dlimits::max(), max = dlimits::min(), total = 0;
	size_t count = 0;
	for (iter_type itr = first; itr != last; itr++) {
		auto val = *itr;
		double vald = val;
		if (vald < min) min = vald;
		if (vald > max) max = vald;
		total += vald;
		count++;
	}

	return DescriptiveStats(min, max, total / count, median(first, last), count);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movsd 0x8ae2(%rip), %xmm6     # 0x1b040
movsd 0x8ae2(%rip), %xmm5     # 0x1b048
xorpd %xmm4, %xmm4
movsd 0x8ade(%rip), %xmm0     # 0x1b050
movapd 0x8ae6(%rip), %xmm1     # 0x1b060
movq %rsi, %rax
cmpq %rdx, %rax
je 0x125b7
movsd (%rax), %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
subpd %xmm1, %xmm2
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
movapd %xmm3, %xmm2
minsd %xmm6, %xmm2
addsd %xmm3, %xmm4
maxsd %xmm5, %xmm3
addq $0x8, %rax
movapd %xmm3, %xmm5
movapd %xmm2, %xmm6
jmp 0x1257d
movq %rdx, %r14
subq %rsi, %r14
shrq $0x3, %r14
cvtsi2sd %r14, %xmm0
divsd %xmm0, %xmm4
movsd %xmm4, 0x10(%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
movsd %xmm5, 0x8(%rsp)
movsd %xmm6, (%rsp)
callq 0x1263a
movq %rax, %xmm0
punpckldq 0x8a5d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x8a65(%rip), %xmm0     # 0x1b060
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd (%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
movsd %xmm1, 0x18(%rbx)
movq %r14, 0x20(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/./stats.hpp
// Function: std::iterator_traits<unsigned long*>::value_type Stats::median<unsigned long*, std::less<unsigned long>>(unsigned long*, unsigned long*, std::less<unsigned long>)
typename std::iterator_traits<iter_type>::value_type median(iter_type first, iter_type last, LESS comp) {
	if (first == last) {
		throw std::logic_error("can't get median of empty range");
	}
	using T = typename std::iterator_traits<iter_type>::value_type;
	std::vector<T> copy(first, last);
	std::sort(copy.begin(), copy.end(), comp);
	size_t sz = copy.size(), half_sz = sz / 2;
	return sz % 2 ? copy[half_sz] : (copy[half_sz - 1] + copy[half_sz]) / 2;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
cmpq %rsi, %rdi
je 0x126ad
movq %rdi, %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x12704
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x127ac
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
subq %rax, %rdx
movq %rdx, %rcx
sarq $0x3, %rcx
shrq %rcx
testb $0x8, %dl
jne 0x12694
movq (%rax,%rcx,8), %rbx
addq -0x8(%rax,%rcx,8), %rbx
shrq %rbx
jmp 0x12698
movq (%rax,%rcx,8), %rbx
leaq 0x10(%rsp), %rdi
callq 0xd7ee
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x6170
movq %rax, %r14
leaq 0xa253(%rip), %rsi      # 0x1c912
movq %rax, %rdi
callq 0x64c0
movq 0x14912(%rip), %rsi     # 0x26fe0
movq 0x148f3(%rip), %rdx     # 0x26fc8
movq %r14, %rdi
callq 0x65e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x6270
jmp 0x126fc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xd7ee
jmp 0x126fc
movq %rax, %rbx
movq %rbx, %rdi
callq 0x65f0
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/cpuid.cpp
// Function: cpuid_result::to_string[abi:cxx11]()
std::string cpuid_result::to_string() {
    std::string s;
    s += "eax = " + std::to_string(eax) + ", ";
    s += "ebx = " + std::to_string(ebx) + ", ";
    s += "ecx = " + std::to_string(ecx) + ", ";
    s += "edx = " + std::to_string(edx);
    return s;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movl (%rsi), %esi
leaq 0x48(%rsp), %rdi
callq 0x13539
leaq 0x9e3a(%rip), %rsi      # 0x1ce8e
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xeb91
leaq 0x8982(%rip), %rdx      # 0x1b9ec
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9a5e
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x6670
leaq 0x28(%rsp), %rdi
callq 0x6140
leaq 0x8(%rsp), %rdi
callq 0x6140
leaq 0x48(%rsp), %rdi
callq 0x6140
movl 0x4(%r14), %esi
leaq 0x48(%rsp), %rdi
callq 0x13539
leaq 0x9ddc(%rip), %rsi      # 0x1ce95
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xeb91
leaq 0x891d(%rip), %rdx      # 0x1b9ec
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9a5e
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x6670
leaq 0x28(%rsp), %rdi
callq 0x6140
leaq 0x8(%rsp), %rdi
callq 0x6140
leaq 0x48(%rsp), %rdi
callq 0x6140
movl 0x8(%r14), %esi
leaq 0x48(%rsp), %rdi
callq 0x13539
leaq 0x9d7e(%rip), %rsi      # 0x1ce9c
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xeb91
leaq 0x88b8(%rip), %rdx      # 0x1b9ec
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9a5e
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x6670
leaq 0x28(%rsp), %rdi
callq 0x6140
leaq 0x8(%rsp), %rdi
callq 0x6140
leaq 0x48(%rsp), %rdi
callq 0x6140
movl 0xc(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x13539
leaq 0x9d20(%rip), %rsi      # 0x1cea3
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xeb91
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x6670
leaq 0x28(%rsp), %rdi
callq 0x6140
leaq 0x8(%rsp), %rdi
callq 0x6140
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x6140
jmp 0x131d0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x1320f
jmp 0x13216
jmp 0x131e9
jmp 0x131f8
jmp 0x13207
jmp 0x13216
jmp 0x131e9
jmp 0x131f8
jmp 0x13207
jmp 0x13216
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x6140
jmp 0x131fb
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6140
jmp 0x1320a
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x6140
jmp 0x13219
movq %rax, %r14
movq %rbx, %rdi
callq 0x6140
movq %r14, %rdi
callq 0x65f0
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/cpuid.cpp
// Function: gfm_inner()
family_model gfm_inner() {
    auto cpuid1 = cpuid(1);
    family_model ret;
    ret.family   = (cpuid1.eax >> 8) & 0xF;
    ret.model    = (cpuid1.eax >> 4) & 0xF;
    ret.stepping = (cpuid1.eax     ) & 0xF;
    if (ret.family == 15) {
        ret.family += (cpuid1.eax >> 20) & 0xFF;  // extended family
    }
    if (ret.family == 15 || ret.family == 6) {
        ret.model += ((cpuid1.eax >> 16) & 0xF) << 4; // extended model
    }
    return ret;
}

// Assembly:
pushq %rax
pushq $0x1
popq %rdi
callq 0x13230
movl %eax, %ecx
shrl $0x8, %ecx
andb $0xf, %cl
movl %eax, %edx
shrb $0x4, %dl
movl %eax, %esi
shrl $0x14, %esi
addb $0xf, %sil
cmpb $0xf, %cl
movzbl %sil, %esi
movzbl %cl, %ecx
cmovel %esi, %ecx
movl %eax, %esi
shrl $0xc, %esi
andb $-0x10, %sil
xorl %edi, %edi
cmpb $0x6, %cl
movzbl %sil, %esi
cmovel %esi, %edi
cmpb $0xf, %cl
cmovel %esi, %edi
orb %dl, %dil
andb $0xf, %al
movzbl %al, %eax
shll $0x10, %eax
movzbl %dil, %edx
shll $0x8, %edx
orl %eax, %edx
movzbl %cl, %eax
orl %edx, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/cpuid.cpp
// Function: get_brand_string[abi:cxx11]()
std::string get_brand_string() {
    auto check = cpuid(0x80000000);
    if (check.eax < 0x80000004) {
        return std::string("unkown (eax =") + std::to_string(check.eax) +")";
    }
    std::string ret;
    for (uint32_t eax : {0x80000002, 0x80000003, 0x80000004}) {
        char buf[17];
        auto fourchars = cpuid(eax);
        memcpy(buf +  0, &fourchars.eax, 4);
        memcpy(buf +  4, &fourchars.ebx, 4);
        memcpy(buf +  8, &fourchars.ecx, 4);
        memcpy(buf + 12, &fourchars.edx, 4);
        buf[16] = '\0';
        ret += buf;
    }
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movl $0x80000000, %edi       # imm = 0x80000000
callq 0x13230
movq %rax, %r14
cmpl $0x80000003, %r14d      # imm = 0x80000003
ja 0x133e1
leaq 0x9b38(%rip), %rsi      # 0x1ceaa
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6100
leaq 0x50(%rsp), %rdi
movl %r14d, %esi
callq 0x13539
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xe88c
leaq 0x908f(%rip), %rdx      # 0x1c438
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x9a5e
leaq 0x10(%rsp), %rdi
callq 0x6140
leaq 0x50(%rsp), %rdi
callq 0x6140
leaq 0x30(%rsp), %rdi
callq 0x6140
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movabsq $-0x7ffffffc7ffffffe, %rax # imm = 0x8000000380000002
movq %rax, 0x30(%rsp)
movl $0x80000004, 0x38(%rsp) # imm = 0x80000004
xorl %r15d, %r15d
leaq 0x10(%rsp), %r14
cmpq $0xc, %r15
je 0x133d4
movl 0x30(%rsp,%r15), %edi
callq 0x13230
movl %eax, 0x10(%rsp)
shrq $0x20, %rax
movl %eax, 0x14(%rsp)
movl %edx, 0x18(%rsp)
shrq $0x20, %rdx
movl %edx, 0x1c(%rsp)
movb $0x0, 0x20(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6640
addq $0x4, %r15
jmp 0x13410
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x6140
jmp 0x13460
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x6140
jmp 0x1346f
movq %rax, %r14
leaq 0x30(%rsp), %rdi
jmp 0x13481
movq %rax, %r14
jmp 0x13486
movq %rax, %r14
movq %rbx, %rdi
callq 0x6140
movq %r14, %rdi
callq 0x65f0
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/cpuid.cpp
// Function: get_smt_shift()
int get_smt_shift()
{
    if (cpuid_highest_leaf() < 0xb) {
        return -1;
    }
    uint32_t smtShift = -1u;
    for (uint32_t subleaf = 0; ; subleaf++) {
        cpuid_result leafb = cpuid(0xb, subleaf);
        uint32_t type  = get_bits(leafb.ecx, 8 ,15);
        if (!get_bits(leafb.ebx,0,15) || type == 0) {
            // done
            break;
        }
        if (type == 1) {
            // here's the value we are after: make sure we don't have more than one entry for
            // this type though!
            if (smtShift != -1u) {
                fprintf(stderr, "Warning: more than one level of type 1 in the x2APIC hierarchy");
            }
            smtShift = get_bits(leafb.eax, 0, 4);
        }
    }
    return smtShift;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x13237
pushq $-0x1
popq %r13
cmpl $0xb, %eax
jae 0x134cd
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
pushq $0xb
popq %rbp
movl %ebp, %edi
movl %ebx, %esi
callq 0x13276
movq %rax, %r14
movzbl %dh, %eax
movq %r14, %rcx
shrq $0x20, %rcx
testw %cx, %cx
sete %cl
setne %r15b
testl %eax, %eax
setne %r12b
cmpl $0x1, %eax
setne %al
orb %cl, %al
jne 0x1350f
cmpl $-0x1, %r13d
jne 0x1351b
andl $0x1f, %r14d
movl %r14d, %r13d
andb %r12b, %r15b
incl %ebx
testb %r15b, %r15b
jne 0x134d2
jmp 0x134bb
movq 0x13aae(%rip), %rax     # 0x26fd0
movq (%rax), %rcx
leaq 0x998c(%rip), %rdi      # 0x1ceb8
pushq $0x3e
popq %rsi
pushq $0x1
popq %rdx
callq 0x6660
jmp 0x13508
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/tsc-support.cpp
// Function: get_tsc_from_cpuid_inner()
uint64_t get_tsc_from_cpuid_inner() {
    if (cpuid_highest_leaf() < 0x15) {
        std::printf("CPUID doesn't support leaf 0x15, falling back to manual TSC calibration.\n");
        return 0;
    }

    auto cpuid15 = cpuid(0x15);
    std::printf("cpuid = %s\n", cpuid15.to_string().c_str());

    if (cpuid15.ecx) {
        // the crystal frequency was present in ECX
        return (uint64_t)cpuid15.ecx * cpuid15.ebx / cpuid15.eax;
    }

    // ecx == 0 means we have to use a hard-coded frequency based on the model and table provided by Intel
    // in 18.7.3
    auto family = get_family_model();
    std::printf("cpu: %s\n", family.to_string().c_str());


    if (family.family == 6) {
        if (family.model == 0x4E || family.model == 0x5E || family.model == 0x8E || family.model == 0x9E) {
            // skylake client or kabylake
            return (int64_t)24000000 * cpuid15.ebx / cpuid15.eax; // 24 MHz crystal clock
        }
    } else {
        std::printf("CPU family not 6 (perhaps AMD or old Intel), falling back to manual TSC calibration.\n");
    }

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
callq 0x13237
cmpl $0x14, %eax
ja 0x13599
leaq 0x9a1b(%rip), %rdi      # 0x1cfab
callq 0x6520
xorl %eax, %eax
jmp 0x135ef
pushq $0x15
popq %rdi
callq 0x13230
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13024
movq (%r14), %rsi
leaq 0x9930(%rip), %rdi      # 0x1cef7
xorl %eax, %eax
callq 0x6050
movq %r14, %rdi
callq 0x6140
movl 0x8(%rbx), %ecx
testq %rcx, %rcx
je 0x135f7
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %eax
imulq %rcx, %rax
xorl %edx, %edx
divq %rsi
addq $0x38, %rsp
popq %rbx
popq %r14
retq
callq 0x132f3
leaq 0x4(%rsp), %rbx
movw %ax, (%rbx)
shrl $0x10, %eax
movb %al, 0x2(%rbx)
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1380e
movq (%r14), %rsi
leaq 0x98df(%rip), %rdi      # 0x1cf03
xorl %eax, %eax
callq 0x6050
movq %r14, %rdi
callq 0x6140
cmpb $0x6, (%rbx)
jne 0x1366f
movzbl 0x5(%rsp), %eax
cmpl $0x4e, %eax
je 0x13659
cmpl $0x5e, %eax
je 0x13659
cmpl $0x9e, %eax
je 0x13659
cmpl $0x8e, %eax
jne 0x13595
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %eax
imulq $0x16e3600, %rax, %rax  # imm = 0x16E3600
xorl %edx, %edx
divq %rcx
jmp 0x135ef
leaq 0x98e0(%rip), %rdi      # 0x1cf56
jmp 0x13590
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/tsc-support.cpp
// Function: do_sample()
uint64_t do_sample() {
    _mm_lfence();
    uint64_t  nsbefore = Clock::nanos();
    uint64_t tscbefore = rdtsc();
    while (nsbefore + DELAY_NANOS > Clock::nanos())
        ;
    uint64_t  nsafter = Clock::nanos();
    uint64_t tscafter = rdtsc();
    return (tscafter - tscbefore) * 1000000000u / (nsafter - nsbefore);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
lfence
callq 0x13726
movq %rax, %rbx
rdtsc
movq %rdx, %r14
shlq $0x20, %r14
orq %rax, %r14
leaq 0x2710(%rbx), %r15
callq 0x13726
cmpq %rax, %r15
ja 0x136f3
callq 0x13726
movq %rax, %rcx
rdtsc
shlq $0x20, %rdx
orq %rax, %rdx
subq %r14, %rdx
imulq $0x3b9aca00, %rdx, %rax # imm = 0x3B9ACA00
subq %rbx, %rcx
xorl %edx, %edx
divq %rcx
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/tsc-support.cpp
// Function: tsc_from_cal()
uint64_t tsc_from_cal() {
    std::array<uint64_t, SAMPLES * 2> samples;

    for (size_t s = 0; s < SAMPLES * 2; s++) {
        samples[s] = do_sample();
    }

    // throw out the first half of samples as a warmup
    std::array<uint64_t, SAMPLES> second_half;
    std::copy(samples.begin() + SAMPLES, samples.end(), second_half.begin());
    std::sort(second_half.begin(), second_half.end());

    // average the middle quintile
    auto third_quintile = second_half.begin() + 2 * SAMPLES/5;
    uint64_t sum = std::accumulate(third_quintile, third_quintile + SAMPLES/5, (uint64_t)0);

    return sum / (SAMPLES/5);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x978, %rsp            # imm = 0x978
xorl %ebx, %ebx
cmpq $0xca, %rbx
je 0x13771
callq 0x136d0
movq %rax, 0x328(%rsp,%rbx,8)
incq %rbx
jmp 0x13756
movl $0x328, %ebx            # imm = 0x328
leaq 0x328(%rsp), %rsi
addq %rbx, %rsi
movq %rsp, %r14
movl $0x328, %edx            # imm = 0x328
movq %r14, %rdi
callq 0x62d0
addq %r14, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x139a9
movl $0x140, %ecx            # imm = 0x140
xorl %eax, %eax
cmpq $0x1e0, %rcx            # imm = 0x1E0
je 0x137b9
addq (%rsp,%rcx), %rax
addq $0x8, %rcx
jmp 0x137a6
pushq $0x14
popq %rcx
xorl %edx, %edx
divq %rcx
addq $0x978, %rsp            # imm = 0x978
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/./cpuid.hpp
// Function: family_model::to_string[abi:cxx11]()
std::string to_string() {
        std::string s;
        s += "family = " + std::to_string(family) + ", ";
        s += "model = " + std::to_string(model) + ", ";
        s += "stepping = " + std::to_string(stepping);
        return s;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movzbl (%rsi), %esi
leaq 0x48(%rsp), %rdi
callq 0x11963
leaq 0x96f8(%rip), %rsi      # 0x1cf37
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xeb91
leaq 0x8197(%rip), %rdx      # 0x1b9ec
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9a5e
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x6670
leaq 0x28(%rsp), %rdi
callq 0x6140
leaq 0x8(%rsp), %rdi
callq 0x6140
leaq 0x48(%rsp), %rdi
callq 0x6140
movzbl 0x1(%r14), %esi
leaq 0x48(%rsp), %rdi
callq 0x11963
leaq 0x969c(%rip), %rsi      # 0x1cf41
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xeb91
leaq 0x8131(%rip), %rdx      # 0x1b9ec
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9a5e
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x6670
leaq 0x28(%rsp), %rdi
callq 0x6140
leaq 0x8(%rsp), %rdi
callq 0x6140
leaq 0x48(%rsp), %rdi
callq 0x6140
movzbl 0x2(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x11963
leaq 0x963f(%rip), %rsi      # 0x1cf4a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xeb91
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x6670
leaq 0x28(%rsp), %rdi
callq 0x6140
leaq 0x8(%rsp), %rdi
callq 0x6140
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x6140
jmp 0x13958
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x1398f
jmp 0x13996
jmp 0x13969
jmp 0x13978
jmp 0x13987
jmp 0x13996
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x6140
jmp 0x1397b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6140
jmp 0x1398a
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x6140
jmp 0x13999
movq %rax, %r14
movq %rbx, %rdi
callq 0x6140
movq %r14, %rdi
callq 0x65f0
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/cpu.c
// Function: psnip_cpu_init
static void psnip_cpu_init(void) {
#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64)
  int i;
  for (i = 0 ; i < 8 ; i++) {
    psnip_cpu_getid(i, (int*) &(psnip_cpuinfo[i * 4]));
  }
#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64)
  psnip_cpuinfo[0] = getauxval (AT_HWCAP);
  psnip_cpuinfo[1] = getauxval (AT_HWCAP2);
#endif
}

// Assembly:
pushq %rbx
leaq 0x1445e(%rip), %rdi     # 0x282ac
xorl %esi, %esi
cmpq $0x8, %rsi
je 0x13e70
movl %esi, %eax
xorl %ecx, %ecx
cpuid
movl %eax, -0xc(%rdi)
movl %ebx, -0x8(%rdi)
movl %ecx, -0x4(%rdi)
movl %edx, (%rdi)
incq %rsi
addq $0x10, %rdi
jmp 0x13e50
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/msr-access.c
// Function: get_rfile
int get_rfile(int cpu) {
    assert(cpu >= 0);

    lock();

    if (cpu >= rfile_size) {
        // expand array
        size_t new_size = rfile_size * 2 > cpu ? rfile_size * 2 : cpu;
        int *new_array = calloc(new_size, sizeof(int));
        memcpy(new_array, rfile_array, rfile_size  * sizeof(int));
        if (rfile_array != rfile_static) {
            free(rfile_array);
        }
        rfile_array = new_array;
        rfile_size  = new_size;
    }

    if (rfile_array[cpu] == 0) {
        char filename[64] = {};
        int ret = snprintf(filename, 64, "/dev/cpu/%d/msr", cpu);
        assert(ret > 0);
        rfile_array[cpu] = open(filename, O_RDONLY);
        if (rfile_array[cpu] == -1) {
            rfile_array[cpu] = -errno;
        }
    }

    int ret = rfile_array[cpu];

    unlock();

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testl %edi, %edi
js 0x13fe0
movl %edi, %ebx
callq 0x13ec8
movslq 0x13474(%rip), %r13     # 0x27378
movq 0x13475(%rip), %r14     # 0x27380
cmpl %ebx, %r13d
jle 0x13f15
movq %r14, %r12
jmp 0x13f66
leal (,%r13,2), %r15d
cmpl %ebx, %r15d
cmovlel %ebx, %r15d
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x6230
movq %rax, %r12
shlq $0x2, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x62d0
leaq 0x14415(%rip), %rax     # 0x28360
cmpq %rax, %r14
je 0x13f58
movq %r14, %rdi
callq 0x63e0
movq %r12, 0x13421(%rip)     # 0x27380
movl %r15d, 0x13412(%rip)    # 0x27378
movl %ebx, %r14d
movl (%r12,%r14,4), %ebp
testl %ebp, %ebp
jne 0x13fca
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
leaq 0x9090(%rip), %rdx      # 0x1d01d
pushq $0x40
popq %rsi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x6570
testl %eax, %eax
jle 0x13ff9
xorl %ebx, %ebx
movq %rsp, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x6280
movl %eax, %ebp
movq 0x133cc(%rip), %r15     # 0x27380
movl %eax, (%r15,%r14,4)
cmpl $-0x1, %eax
jne 0x13fca
callq 0x6040
subl (%rax), %ebx
movl %ebx, (%r15,%r14,4)
movl %ebx, %ebp
callq 0x13ed4
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x900d(%rip), %rdi      # 0x1cff4
leaq 0x900f(%rip), %rsi      # 0x1cffd
leaq 0x9015(%rip), %rcx      # 0x1d00a
pushq $0x36
jmp 0x14010
leaq 0x902d(%rip), %rdi      # 0x1d02d
leaq 0x8ff6(%rip), %rsi      # 0x1cffd
leaq 0x8ffc(%rip), %rcx      # 0x1d00a
pushq $0x49
popq %rdx
callq 0x6220
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/msr-access.c
// Function: read_msr
int read_msr(int cpu, uint32_t msr_index, uint64_t* value) {
    int file = get_rfile(cpu);
    assert(file);
    if (file < 0) {
        // file open failes are stored as negative errno
        return file;
    }
    int read = pread(file, value, 8, msr_index);
    return read == -1 ? errno : 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
callq 0x13ee0
testl %eax, %eax
je 0x14050
js 0x14049
movl %ebp, %ecx
pushq $0x8
popq %rdx
movl %eax, %edi
movq %rbx, %rsi
callq 0x6410
movq %rax, %rcx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x14049
callq 0x6040
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8fde(%rip), %rdi      # 0x1d035
leaq 0x8f9f(%rip), %rsi      # 0x1cffd
leaq 0x8fd5(%rip), %rcx      # 0x1d03a
pushq $0x59
popq %rdx
callq 0x6220
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/msr-access.c
// Function: test
int test(int argc, char** argv) {
    assert(argc == 3);
    int cpu      = atoi(argv[1]);
    uint32_t msr = atoi(argv[2]);
    printf("reading msr %u from cpu %d\n", msr, cpu);
    uint64_t value = -1;

    int res = read_msr(cpu, msr, &value);
    if (res) {
        printf("error %d\n", res);
    } else {
        printf("value %lx\n", value);
    }

    res = read_msr_cur_cpu(msr, &value);
    if (res) {
        printf("error %d\n", res);
    } else {
        printf("value %lx\n", value);
    }

    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x3, %edi
jne 0x14136
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x6530
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x6530
movl %eax, %ebx
leaq 0x8fcb(%rip), %rdi      # 0x1d083
movl %eax, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x6050
movq %rsp, %rdx
orq $-0x1, (%rdx)
movl %ebp, %edi
movl %ebx, %esi
callq 0x14016
testl %eax, %eax
je 0x140e9
leaq 0x8fc1(%rip), %rdi      # 0x1d09f
movl %eax, %esi
xorl %eax, %eax
callq 0x6050
jmp 0x140fb
movq (%rsp), %rsi
leaq 0x8fb5(%rip), %rdi      # 0x1d0a9
xorl %eax, %eax
callq 0x6050
movq %rsp, %rsi
movl %ebx, %edi
callq 0x1406d
testl %eax, %eax
je 0x1411b
leaq 0x8f8f(%rip), %rdi      # 0x1d09f
movl %eax, %esi
xorl %eax, %eax
callq 0x6050
jmp 0x1412d
movq (%rsp), %rsi
leaq 0x8f83(%rip), %rdi      # 0x1d0a9
xorl %eax, %eax
callq 0x6050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8f25(%rip), %rdi      # 0x1d062
leaq 0x8eb9(%rip), %rsi      # 0x1cffd
leaq 0x8f21(%rip), %rcx      # 0x1d06c
pushq $0x6a
popq %rdx
callq 0x6220
nop
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]avx-turbo/nasm-utils-helper.c
// Function: nasm_util_die_on_reg_clobber
void nasm_util_die_on_reg_clobber(const char *fname, unsigned reg_id) {
    reg_id--; // reg ids are 1-based
    if (reg_id >= sizeof(sizeof(reg_names)/sizeof(reg_names[0]))) {
        fprintf(stderr, "FATAL: function %s clobbered a callee-saved register (thunk returned an invalid reg_id %d)\n",
                fname, reg_id);
    } else {
        fprintf(stderr, "FATAL: function %s clobbered callee-saved register %s\n", fname, reg_names[reg_id]);
    }
    abort();
}

// Assembly:
pushq %rax
movl %esi, %ecx
movq %rdi, %rdx
decl %ecx
cmpl $0x8, %ecx
jb 0x1417e
movq 0x12e68(%rip), %rax     # 0x26fd0
movq (%rax), %rdi
leaq 0x8f42(%rip), %rsi      # 0x1d0b4
xorl %eax, %eax
callq 0x64b0
callq 0x61c0
movl %ecx, %eax
movq 0x12e49(%rip), %rcx     # 0x26fd0
movq (%rcx), %rdi
leaq 0x8ff3(%rip), %rsi      # 0x1d184
movslq (%rsi,%rax,4), %rcx
addq %rsi, %rcx
leaq 0x8f71(%rip), %rsi      # 0x1d110
xorl %eax, %eax
callq 0x64b0
callq 0x61c0
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::~Preprocessor()
~Preprocessor()
        {
            if (macros) {
                while (nmacros > 0)
                    delete_macro(nmacros-1);
                free(macros);
            }

            if (S) {
                free(S->op_set);
                free(S->ext_op_set);
                free(S->id_set);
                free_comments(S);
                free(S);
            }

            if (C) {
                free(C->malloced_buf);
                free(C->out);
                free(C);
            }
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x28e5
jmp 0x28f5
decl %esi
movq %rbx, %rdi
callq 0x5d80
movl 0x10(%rbx), %esi
testl %esi, %esi
jg 0x28db
movq 0x8(%rbx), %rdi
callq 0x2160
movq (%rbx), %rax
testq %rax, %rax
je 0x2937
movq 0xa0(%rax), %rdi
callq 0x2160
movq (%rbx), %rax
movq 0xa8(%rax), %rdi
callq 0x2160
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
callq 0x2160
movq (%rbx), %rdi
callq 0x66c8
movq (%rbx), %rdi
callq 0x2160
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x2960
movq 0x8(%rax), %rdi
callq 0x2160
movq 0x20(%rbx), %rax
movq 0x38(%rax), %rdi
callq 0x2160
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x2160
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::add_comment((anonymous namespace)::Specs*, char const*, char*, char*, char, char)
void add_comment(Specs *S, const char *specif, char *start, char *end, char quote, char warn) {
        Comment *p;

        if (*start == 0)
            bug("comment/string start delimiter must be non-empty");
        for (p = S->comments; p != nullptr ; p = p->next)
            if (!strcmp(p->start, start)) {
                if (strcmp(p->end, end)) // already exists with a different end
                    bug("conflicting comment/string delimiter specifications");
                free(p->start);
                free(p->end);
                break;
            }

        if (p == nullptr ) {
            p = XX malloc(sizeof *p);
            p->next = S->comments;
            S->comments = p;
        }
        p->start = start;
        p->end = end;
        p->quote = quote;
        p->warn = warn;
        if (strlen(specif) != 3)
            bug("invalid comment/string modifier");
        p->flags[FLAG_META] = parse_comment_specif(specif[0]);
        p->flags[FLAG_USER] = parse_comment_specif(specif[1]);
        p->flags[FLAG_TEXT] = parse_comment_specif(specif[2]);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, (%rsp)
cmpb $0x0, (%rdx)
je 0x2cb3
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %rbp
addq $0x90, %rbp
movq %rbp, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x2c1c
movq (%r14), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x21a0
testl %eax, %eax
je 0x2c35
addq $0x20, %r14
jmp 0x2bfc
pushq $0x28
popq %rdi
callq 0x2170
movq %rax, %r14
movq (%rbp), %rax
movq %rax, 0x20(%r14)
movq %r14, (%rbp)
jmp 0x2c5a
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x21a0
testl %eax, %eax
jne 0x2ccb
movq %r15, %rdi
callq 0x2160
movq 0x8(%r14), %rdi
callq 0x2160
movq %r13, (%r14)
movq %r12, 0x8(%r14)
movl (%rsp), %eax
movb %al, 0x10(%r14)
movl 0x4(%rsp), %eax
movb %al, 0x11(%r14)
movq %rbx, %rdi
callq 0x2080
cmpq $0x3, %rax
jne 0x2cbf
movsbl (%rbx), %edi
callq 0x2d59
movl %eax, 0x14(%r14)
movsbl 0x1(%rbx), %edi
callq 0x2d59
movl %eax, 0x18(%r14)
movsbl 0x2(%rbx), %edi
callq 0x2d59
movl %eax, 0x1c(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5802(%rip), %rdi      # 0x84bc
callq 0x2d13
leaq 0x585b(%rip), %rdi      # 0x8521
callq 0x2d13
leaq 0x581b(%rip), %rdi      # 0x84ed
callq 0x2d13
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::find_comment_end(char const*, char, char, int, int)
int find_comment_end(const char *endseq, char quote, char warn, int pos,
                int flags) {
            int i;
            char c;

            while (1) {
                c = get_char(pos);
                i = pos;
                if (match_end_sequence(endseq, &i))
                    return pos;
                if (c == 0)
                    bug("input ended while scanning a comment/string");
                if (c == warn) {
                    warn = 0;
                    if (warning_level > 1)
                        warning("possible comment/string termination problem");
                }
                if (c == quote)
                    pos += 2;
                else if ((flags & PARSE_MACROS) && (c == S->user.quotechar))
                    pos += 2;
                else
                    pos++;
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, (%rsp)
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movq %r12, %rdi
movl %ebx, %esi
callq 0x5932
movl %eax, %r13d
movl %ebx, 0x4(%rsp)
movq %r12, %rdi
movq %r15, %rsi
leaq 0x4(%rsp), %rdx
callq 0x5432
testl %eax, %eax
jne 0x5414
testb %r13b, %r13b
je 0x5425
cmpb %bpl, %r13b
jne 0x53f5
cmpw $0x2, 0x18(%r12)
jl 0x53f3
leaq 0x317f(%rip), %rdi      # 0x856d
callq 0x5a8f
xorl %ebp, %ebp
pushq $0x2
popq %rax
cmpb %r14b, %r13b
je 0x5410
testb $0x4, (%rsp)
je 0x540d
movq (%r12), %rcx
cmpb 0x30(%rcx), %r13b
je 0x5410
pushq $0x1
popq %rax
addl %eax, %ebx
jmp 0x53af
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3115(%rip), %rdi      # 0x8541
callq 0x2d13
nop
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::match_end_sequence(char const*, int*)
int match_end_sequence(const char *s, int *pos) {
            if (*s == 0)
                return 1;
            // if terminator is \n and we're at end of input, let it be...
            if (get_char(*pos) == 0 && s[0] == '\n' && s[1] == 0)
                return 1;
            if (!match_sequence(s, pos))
                return 0;
            return 1;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x0, (%rsi)
je 0x5470
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %esi
callq 0x5932
testb %al, %al
jne 0x545d
cmpb $0xa, (%r14)
jne 0x545d
cmpb $0x0, 0x1(%r14)
je 0x5470
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x56be
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::sendout(char const*, int, int)
void sendout(const char *s, int l, int proc) // only process the quotechar, that's all
        {
            int i;

            if (!commented[iflevel])
                for (i = 0; i < l; i++) {
                    if (proc && (s[i] != 0) && (s[i] == S->user.quotechar)) {
                        i++;
                        if (i == l)
                            return;
                    }
                    if (s[i] != 0)
                        outchar(s[i]);
                }
        }

// Assembly:
movslq 0xf0(%rdi), %rax
cmpl $0x0, 0x28(%rdi,%rax,4)
je 0x5489
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
cmpl %ebp, %r12d
jge 0x54dd
testl %ebx, %ebx
je 0x54c2
movslq %r12d, %rax
movb (%r14,%rax), %al
testb %al, %al
je 0x54c2
movq (%r15), %rcx
cmpb 0x30(%rcx), %al
jne 0x54c2
incl %r12d
cmpl %ebp, %r12d
je 0x54dd
movslq %r12d, %rax
movb (%r14,%rax), %al
testb %al, %al
je 0x54d8
movsbl %al, %esi
movq %r15, %rdi
callq 0x5aaa
incl %r12d
jmp 0x549e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::process_text(char const*, int, int)
char *process_text(const char *buf, int l, int ambience) {
            char *s;
            Input_Context *T;

            if (l == 0) {
                s = XX malloc(1);
                s[0] = 0;
                return s;
            }
            s = XX malloc(l + 2);
            s[0] = '\n';
            memcpy(s + 1, buf, l);
            s[l + 1] = 0;
            T = C;
            C = XX malloc(sizeof *C);
            C->out = XX malloc(sizeof *(C->out));
            C->read_stdin = 0;
            C->argc = T->argc;
            C->argv = T->argv;
            C->out->buf = XX malloc(80);
            C->out->len = 0;
            C->out->bufsize = 80;
            C->out->output_char = T->out->output_char;
            C->out->output_char_data = T->out->output_char_data;
            C->lineno = T->lineno;
            C->bufsize = l + 2;
            C->len = l + 1;
            C->buf = C->malloced_buf = s;
            C->eof = 0;
            C->namedargs = T->namedargs;
            C->in_comment = T->in_comment;
            C->ambience = ambience;
            C->may_have_args = T->may_have_args;

            process_context();
            outchar(0); // note that outchar works with the half-destroyed context !
            s = C->out->buf;
            free(C->out);
            free(C);
            C = T;
            return s;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %edx, %edx
je 0x5601
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r15
leal 0x2(%r12), %eax
movslq %eax, %rdi
movq %rdi, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
callq 0x2170
movq %rax, %r14
movb $0xa, (%rax)
leaq 0x1(%rax), %rdi
movslq %r12d, %r12
movq %r13, %rsi
movq %r12, %rdx
callq 0x20f0
movb $0x0, 0x1(%r14,%r12)
incq %r12
movq 0x20(%r15), %rbx
pushq $0x50
popq %rdi
callq 0x2170
movq %rax, %r13
movq %rax, 0x20(%r15)
pushq $0x20
popq %rdi
callq 0x2170
movq %rax, %rbp
movq %rax, 0x38(%r13)
andl $0x0, 0x1c(%r13)
movl 0x20(%rbx), %eax
movl %eax, 0x20(%r13)
pushq $0x50
popq %rdi
callq 0x2170
movq %rax, (%rbp)
movabsq $0x5000000000, %rax     # imm = 0x5000000000
movq %rax, 0x8(%rbp)
movq 0x38(%rbx), %rax
movups 0x10(%rax), %xmm0
movups %xmm0, 0x10(%rbp)
movl 0x18(%rbx), %eax
movl %eax, 0x18(%r13)
movq 0x10(%rsp), %rax
movl %eax, 0x14(%r13)
movl %r12d, 0x10(%r13)
movq %r14, 0x8(%r13)
movq %r14, (%r13)
andl $0x0, 0x40(%r13)
movups 0x28(%rbx), %xmm0
movups %xmm0, 0x28(%r13)
movl 0x44(%rbx), %eax
movl %eax, 0x44(%r13)
movl 0xc(%rsp), %eax
movl %eax, 0x48(%r13)
movl 0x4c(%rbx), %eax
movl %eax, 0x4c(%r13)
movq %r15, %rdi
callq 0x2da8
movq %r15, %rdi
xorl %esi, %esi
callq 0x5aaa
movq 0x20(%r15), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %r14
callq 0x2160
movq 0x20(%r15), %rdi
callq 0x2160
movq %rbx, 0x20(%r15)
jmp 0x560f
pushq $0x1
popq %rdi
callq 0x2170
movq %rax, %r14
movb $0x0, (%rax)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::shift_in(int)
void shift_in(int l) {
            int i;

            if (l <= 1)
                return;
            l--;
            if (l >= C->len)
                C->len = 0;
            else {
                if (C->len - l > 100) { // we want to shrink that buffer
                    C->buf += l;
                    C->bufsize -= l;
                } else
                    for (i = l; i < C->len; i++)
                        C->buf[i - l] = C->buf[i];
                C->len -= l;
                C->eof = (C->buf[0] == 0);
            }
            if (C->len <= 1) {
                if (C->read_stdin)
                    C->eof = feof(stdin);
                else
                    C->eof = 1;
            }
        }

// Assembly:
cmpl $0x2, %esi
jl 0x56bc
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
movl 0x10(%rcx), %eax
cmpl %esi, %eax
jge 0x5640
andl $0x0, 0x10(%rcx)
jmp 0x569a
decl %esi
movl %eax, %edx
subl %esi, %edx
cmpl $0x64, %edx
jle 0x5658
movl %esi, %edi
addq (%rcx), %rdi
movq %rdi, (%rcx)
subl %esi, 0x14(%rcx)
jmp 0x5687
movl %esi, %edx
xorl %r8d, %r8d
leaq (%rdx,%r8), %r9
movslq %eax, %r10
movq (%rcx), %rdi
cmpq %r10, %r9
jge 0x5683
leaq (%rdi,%r8), %rax
movb (%rdx,%rax), %al
movb %al, (%rdi,%r8)
movq 0x20(%rbx), %rcx
movl 0x10(%rcx), %eax
incq %r8
jmp 0x565d
subl %esi, %eax
movl %eax, %edx
movl %edx, 0x10(%rcx)
xorl %eax, %eax
cmpb $0x0, (%rdi)
sete %al
movl %eax, 0x40(%rcx)
cmpl $0x1, %edx
jg 0x56bb
cmpl $0x0, 0x1c(%rcx)
je 0x56b5
movq 0x6909(%rip), %rax      # 0xbfb0
movq (%rax), %rdi
callq 0x21f0
movq 0x20(%rbx), %rcx
jmp 0x56b8
pushq $0x1
popq %rax
movl %eax, 0x40(%rcx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::get_char(int)
char get_char(int pos) {
            static int lastchar = -666;
            int c;

            if (lastchar == -666 && !strcmp(S->meta.macro_end, "\n"))
                lastchar = '\n';

            if (!C->read_stdin) {
                if (pos >= C->len)
                    return 0;
                else
                    return C->buf[pos];
            }
            extend_buf(pos);
            while (pos >= C->len) {
                do {
                    c = getchar();
                } while (c == 13);
                if (lastchar == '\n')
                    C->lineno++;
                lastchar = c;
                if (c == EOF)
                    c = 0;
                C->buf[C->len++] = (char) c;
            }
            return C->buf[pos];
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
cmpl $0xfffffd66, 0x67ff(%rip) # imm = 0xFFFFFD66
jne 0x5967
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpb $0xa, (%rax)
jne 0x5967
cmpb $0x0, 0x1(%rax)
jne 0x5967
movl $0xa, 0x67e1(%rip)      # 0xc148
movq 0x20(%r14), %r12
cmpl $0x0, 0x1c(%r12)
je 0x5a04
movl 0x14(%r12), %eax
cmpl %ebx, %eax
jg 0x59bf
addl %ebx, %eax
movl %eax, 0x14(%r12)
movslq %eax, %rdi
callq 0x2170
movq %rax, %r15
movq (%r12), %rsi
movslq 0x10(%r12), %rdx
movq %rax, %rdi
callq 0x20f0
movq 0x8(%r12), %rdi
callq 0x2160
movq 0x20(%r14), %r12
movq %r15, (%r12)
movq %r15, 0x8(%r12)
testq %r15, %r15
je 0x5a22
xorl %ebp, %ebp
cmpl %ebx, 0x10(%r12)
jg 0x5a0b
callq 0x2180
cmpl $0xd, %eax
je 0x59c8
cmpl $0xa, 0x676f(%rip)      # 0xc148
movq 0x20(%r14), %rcx
jne 0x59e2
incl 0x18(%rcx)
movl %eax, 0x6760(%rip)      # 0xc148
cmpl $-0x1, %eax
cmovel %ebp, %eax
movq (%rcx), %rdx
movslq 0x10(%rcx), %rsi
leal 0x1(%rsi), %edi
movl %edi, 0x10(%rcx)
movb %al, (%rdx,%rsi)
movq 0x20(%r14), %r12
jmp 0x59c1
cmpl %ebx, 0x10(%r12)
jle 0x5a1e
movq (%r12), %rax
movslq %ebx, %rcx
movb (%rax,%rcx), %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x5a15
leaq 0x2b7d(%rip), %rdi      # 0x85a6
callq 0x2d13
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::identifier_end(int)
int identifier_end(int start) {
            char c;

            c = get_char(start);
            if (c == 0)
                return start;
            if (c == S->user.quotechar) {
                c = get_char(start + 1);
                if (c == 0)
                    return (start + 1);
                if (is_delim(c))
                    return (start + 2);
                start += 2;
                c = get_char(start);
            }
            while (!is_delim(c))
                c = get_char(++start);
            return start;
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x5932
testb %al, %al
je 0x5a6c
movq (%r14), %rcx
cmpb 0x30(%rcx), %al
jne 0x5a7f
leal 0x1(%rbx), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x5932
testb %al, %al
je 0x5a6e
movzbl %al, %edi
callq 0x7508
addl $0x2, %ebx
movl %ebx, %ebp
testl %eax, %eax
jne 0x5a6e
jmp 0x5a75
movl %ebx, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movl %ebx, %esi
callq 0x5932
movzbl %al, %edi
callq 0x7508
testl %eax, %eax
jne 0x5a6c
incl %ebx
jmp 0x5a75
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::outchar(char)
void outchar(char c) {
            if (C->out->bufsize) {
                if (C->out->len + 1 == C->out->bufsize) {
                    C->out->bufsize = C->out->bufsize * 2;
                    C->out->buf = XX realloc(C->out->buf, C->out->bufsize);
                    if (C->out->buf == nullptr )
                        bug("out of memory");
                }
                C->out->buf[C->out->len++] = c;
            } else {
                if (c != 13) {
                    C->out->output_char(c, C->out->output_char_data);
                }
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x20(%rdi), %rax
movq 0x38(%rax), %rcx
movslq 0xc(%rcx), %rsi
testq %rsi, %rsi
je 0x5af4
movq %rdi, %r14
movl 0x8(%rcx), %edx
leal 0x1(%rdx), %edi
cmpl %esi, %edi
jne 0x5b0d
addq %rsi, %rsi
movl %esi, 0xc(%rcx)
movq (%rcx), %rdi
callq 0x2210
movq 0x20(%r14), %rcx
movq 0x38(%rcx), %rcx
movq %rax, (%rcx)
testq %rax, %rax
je 0x5b21
movl 0x8(%rcx), %edx
leal 0x1(%rdx), %edi
jmp 0x5b10
cmpb $0xd, %bl
je 0x5b19
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rsi
movsbl %bl, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq (%rcx), %rax
movl %edi, 0x8(%rcx)
movslq %edx, %rcx
movb %bl, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2a7e(%rip), %rdi      # 0x85a6
callq 0x2d13
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::id_equal(char const*, int, char const*)
int id_equal(const char *b, int l, const char *s) {
        int i;

        if ((int) strlen(s) != l)
            return 0;
        for (i = 0; i < l; i++)
            if (b[i] != s[i])
                return 0;
        return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movq %rdx, %rdi
callq 0x2080
cmpl %r14d, %eax
jne 0x5b69
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
pushq $0x1
popq %rax
cmpq %rcx, %r14
je 0x5b6b
movb (%r15,%rcx), %dl
leaq 0x1(%rcx), %rsi
cmpb (%rbx,%rcx), %dl
movq %rsi, %rcx
je 0x5b54
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::push_specs((anonymous namespace)::Specs const*)
void push_specs(const Specs *X) {
            Specs *P;

            P = clone_specs(X);
            P->stack_next = S;
            S = P;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x62ca
movq (%rbx), %rcx
movq %rcx, 0x98(%rax)
movq %rax, (%rbx)
popq %rbx
retq