LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x149a0
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x14981
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x14981
movq %rcx, %xmm1
movq 0x96ea(%rip), %xmm2     # 0x1e030
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x96ee(%rip), %xmm3     # 0x1e040
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 0xafea(%rip), %rdi      # 0x1f972
leaq 0x9cf9(%rip), %rsi      # 0x1e688
leaq 0xafbf(%rip), %rcx      # 0x1f955
movl $0x13e, %edx            # imm = 0x13E
callq 0x6210
leaq 0xae30(%rip), %rdi      # 0x1f7d7
leaq 0x9cda(%rip), %rsi      # 0x1e688
leaq 0xafa0(%rip), %rcx      # 0x1f955
movl $0x13d, %edx            # imm = 0x13D
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x149fe
movq %rdi, %rbx
movl $0x0, 0x20(%rdi)
movl $0xe7, %edi
callq 0x14a8c
movq %rax, 0x8(%rbx)
movl $0xe8, %edi
callq 0x14a8c
movq %rax, 0x10(%rbx)
rdtsc
shlq $0x20, %rdx
orq %rax, %rdx
movq %rdx, 0x18(%rbx)
popq %rbx
retq
leaq 0xadd2(%rip), %rdi      # 0x1f7d7
leaq 0x9c7c(%rip), %rsi      # 0x1e688
leaq 0xadd5(%rip), %rcx      # 0x1f7e8
movl $0x11f, %edx            # imm = 0x11F
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14a66
movq %rdi, %rbx
movl $0xe7, %edi
callq 0x14a8c
subq 0x8(%rbx), %rax
movq %rax, 0x8(%rbx)
movl $0xe8, %edi
callq 0x14a8c
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 0xadce(%rip), %rdi      # 0x1f83b
leaq 0x9c14(%rip), %rsi      # 0x1e688
leaq 0xadd1(%rip), %rcx      # 0x1f84c
movl $0x129, %edx            # imm = 0x129
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq $-0x1, (%rsi)
callq 0x16d7b
testl %eax, %eax
jne 0x14aa6
movq (%rsp), %rax
popq %rcx
retq
leaq 0xad5b(%rip), %rdi      # 0x1f808
leaq 0x9bd4(%rip), %rsi      # 0x1e688
leaq 0xad56(%rip), %rcx      # 0x1f811
movl $0x111, %edx            # imm = 0x111
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
movq %rdi, %rbx
cmpq %rdx, %rsi
je 0x14c06
xorpd %xmm5, %xmm5
movsd 0x9505(%rip), %xmm2     # 0x1e0b0
movsd 0x94f5(%rip), %xmm3     # 0x1e0a8
xorl %r14d, %r14d
movsd 0x9472(%rip), %xmm0     # 0x1e030
movapd 0x947a(%rip), %xmm1     # 0x1e040
movq %rsi, %rax
movsd (%rax), %xmm4
unpcklps %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1]
subpd %xmm1, %xmm4
movapd %xmm4, %xmm6
unpckhpd %xmm4, %xmm6            # xmm6 = xmm6[1],xmm4[1]
addsd %xmm4, %xmm6
movapd %xmm6, %xmm4
minsd %xmm3, %xmm4
addsd %xmm6, %xmm5
maxsd %xmm2, %xmm6
incq %r14
addq $0x8, %rax
movapd %xmm4, %xmm3
movapd %xmm6, %xmm2
cmpq %rdx, %rax
jne 0x14bc9
jmp 0x14c1d
movsd 0x949a(%rip), %xmm4     # 0x1e0a8
movsd 0x949a(%rip), %xmm6     # 0x1e0b0
xorpd %xmm5, %xmm5
xorl %r14d, %r14d
movapd %xmm4, 0x10(%rsp)
movapd %xmm6, 0x20(%rsp)
movq %r14, %xmm0
punpckldq 0x93fa(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x9402(%rip), %xmm0     # 0x1e040
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm5
movsd %xmm5, 0x8(%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x14cb2
movq %rax, %xmm0
punpckldq 0x93c4(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x93cc(%rip), %xmm0     # 0x1e040
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movaps 0x10(%rsp), %xmm0
movsd %xmm0, (%rbx)
movaps 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
movsd %xmm1, 0x18(%rbx)
movq %r14, 0x20(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14d58
movq %rdi, %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x14db6
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x14d1f
movq %r14, %rax
subq %rbx, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14e6d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14f56
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %rax
jmp 0x14d22
movq %rbx, %rax
subq %rbx, %rax
movq %rax, %rcx
sarq $0x3, %rcx
shrq %rcx
testb $0x8, %al
jne 0x14d41
movq (%rbx,%rcx,8), %r14
addq -0x8(%rbx,%rcx,8), %r14
shrq %r14
jmp 0x14d45
movq (%rbx,%rcx,8), %r14
movq %rbx, %rdi
callq 0x6320
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x6150
movq %rax, %r14
leaq 0xab87(%rip), %rsi      # 0x1f8f3
movq %rax, %rdi
callq 0x64a0
movq 0x1325d(%rip), %rsi     # 0x27fd8
movq 0x1323e(%rip), %rdx     # 0x27fc0
movq %r14, %rdi
callq 0x65d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x6260
jmp 0x14dae
movq %rax, %rbx
jmp 0x14dae
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14dae
callq 0x6320
movq %rbx, %rdi
callq 0x65f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
callq 0x15c33
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpl $0xb, %eax
jae 0x15fec
movl %esi, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
movl $0xb, %eax
movl %ebp, %ecx
cpuid
movl %eax, %r14d
movzbl %ch, %eax
testl $0xffff, %ebx           # imm = 0xFFFF
sete %cl
setne %bl
testl %eax, %eax
setne %r15b
cmpl $0x1, %eax
setne %al
orb %cl, %al
jne 0x16025
cmpl $-0x1, %esi
jne 0x16030
andl $0x1f, %r14d
movl %r14d, %esi
andb %r15b, %bl
incl %ebp
testb %bl, %bl
jne 0x15fee
jmp 0x15fdf
callq 0x67fd
jmp 0x1601e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x15c33
cmpl $0x14, %eax
ja 0x16059
leaq 0x9f3b(%rip), %rdi      # 0x1ff8b
callq 0x6500
xorl %eax, %eax
jmp 0x160b9
movl $0x15, %edi
callq 0x15c18
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x15604
movq (%rbx), %rsi
leaq 0x9e51(%rip), %rdi      # 0x1fed7
xorl %eax, %eax
callq 0x6050
movq (%rbx), %rdi
leaq 0x28(%rsp), %r14
cmpq %r14, %rdi
je 0x1609f
callq 0x6320
movl 0x10(%rsp), %ecx
testq %rcx, %rcx
je 0x160c1
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 0x15cce
leaq 0x4(%rsp), %rsi
movw %ax, (%rsi)
shrl $0x10, %eax
movb %al, 0x2(%rsi)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x1634a
movq (%rbx), %rsi
leaq 0x9df8(%rip), %rdi      # 0x1fee3
xorl %eax, %eax
callq 0x6050
movq (%rbx), %rdi
cmpq %r14, %rdi
je 0x160ff
callq 0x6320
cmpb $0x6, 0x4(%rsp)
jne 0x16121
movzbl 0x5(%rsp), %ecx
xorl %eax, %eax
cmpl $0x8d, %ecx
jg 0x1612d
cmpl $0x4e, %ecx
je 0x16141
cmpl $0x5e, %ecx
je 0x16141
jmp 0x160b9
leaq 0x9e0e(%rip), %rdi      # 0x1ff36
jmp 0x16050
cmpl $0x9e, %ecx
je 0x16141
cmpl $0x8e, %ecx
jne 0x160b9
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %eax
imulq $0x16e3600, %rax, %rax  # imm = 0x16E3600
xorl %edx, %edx
divq %rcx
jmp 0x160b9
// File: /workspace/github_cpp_makefile_star2_O3/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
callq 0x161af
movq %rax, 0x328(%rsp,%rbx,8)
incq %rbx
cmpq $0xca, %rbx
jne 0x16268
movl $0x328, %ebx            # imm = 0x328
leaq 0x328(%rsp), %rsi
addq %rbx, %rsi
movq %rsp, %r14
movl $0x328, %edx            # imm = 0x328
movq %r14, %rdi
callq 0x62c0
addq %r14, %rbx
movl $0xc, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16757
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1683e
pxor %xmm0, %xmm0
movl $0x28, %eax
movdqu (%rsp,%rax,8), %xmm1
paddq %xmm1, %xmm0
addq $0x2, %rax
cmpq $0x3c, %rax
jne 0x162c8
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddq %xmm0, %xmm1
movq %xmm1, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
mulq %rcx
movq %rdx, %rax
shrq $0x4, %rax
addq $0x978, %rsp            # imm = 0x978
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/travisdowns[P]avx-turbo/cpu.c
// Function: psnip_cpu_feature_check_many
int
psnip_cpu_feature_check_many (enum PSnipCPUFeature* feature) {
  int n;

  for (n = 0 ; feature[n] != PSNIP_CPU_FEATURE_NONE ; n++)
    if (!psnip_cpu_feature_check(feature[n]))
      return 0;

  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %edi
movl $0x1, %ebx
testl %edi, %edi
je 0x16b7e
addq $0x4, %r14
callq 0x16ab0
testl %eax, %eax
je 0x16b7c
movl (%r14), %edi
addq $0x4, %r14
testl %edi, %edi
jne 0x16b66
jmp 0x16b7e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16ce2
movl %edi, %ebx
leaq 0x12721(%rip), %rdi     # 0x29310
callq 0x64c0
movslq 0x1175d(%rip), %r13     # 0x28358
movq 0x1175e(%rip), %r14     # 0x28360
cmpl %ebx, %r13d
jle 0x16c0c
movq %r14, %r12
jmp 0x16c5f
leal (,%r13,2), %r15d
cmpl %ebx, %r15d
cmovlel %ebx, %r15d
movl $0x4, %esi
movq %r15, %rdi
callq 0x6220
movq %rax, %r12
shlq $0x2, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x62c0
leaq 0x126fc(%rip), %rax     # 0x29340
cmpq %rax, %r14
je 0x16c51
movq %r14, %rdi
callq 0x63d0
movq %r12, 0x11708(%rip)     # 0x28360
movl %r15d, 0x116f9(%rip)    # 0x28358
movl %ebx, %r14d
movl (%r12,%r14,4), %ebp
testl %ebp, %ebp
jne 0x16cc5
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
leaq 0x9377(%rip), %rdx      # 0x1fffd
movl $0x40, %esi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x6550
testl %eax, %eax
jle 0x16d01
xorl %ebx, %ebx
movq %rsp, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x6270
movl %eax, %ebp
movq 0x116b1(%rip), %r15     # 0x28360
movl %eax, (%r15,%r14,4)
cmpl $-0x1, %eax
jne 0x16cc5
callq 0x6040
subl (%rax), %ebx
movl %ebx, (%r15,%r14,4)
movl %ebx, %ebp
leaq 0x12644(%rip), %rdi     # 0x29310
callq 0x6290
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x92eb(%rip), %rdi      # 0x1ffd4
leaq 0x92ed(%rip), %rsi      # 0x1ffdd
leaq 0x92f3(%rip), %rcx      # 0x1ffea
movl $0x36, %edx
callq 0x6210
leaq 0x9305(%rip), %rdi      # 0x2000d
leaq 0x92ce(%rip), %rsi      # 0x1ffdd
leaq 0x92d4(%rip), %rcx      # 0x1ffea
movl $0x49, %edx
callq 0x6210
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16bd0
testl %eax, %eax
je 0x16d5c
js 0x16d55
movl %ebp, %ecx
movl $0x8, %edx
movl %eax, %edi
movq %rbx, %rsi
callq 0x6400
movq %rax, %rcx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x16d55
callq 0x6040
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x92b2(%rip), %rdi      # 0x20015
leaq 0x9273(%rip), %rsi      # 0x1ffdd
leaq 0x92a9(%rip), %rcx      # 0x2001a
movl $0x59, %edx
callq 0x6210
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16e4e
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x6520
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x6520
movl %eax, %ebx
leaq 0x929d(%rip), %rdi      # 0x20063
movl %eax, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x6050
movq %rsp, %rdx
movq $-0x1, (%rdx)
movl %ebp, %edi
movl %ebx, %esi
callq 0x16d20
testl %eax, %eax
je 0x16dfa
leaq 0x9290(%rip), %rdi      # 0x2007f
movl %eax, %esi
xorl %eax, %eax
callq 0x6050
jmp 0x16e0c
movq (%rsp), %rsi
leaq 0x9284(%rip), %rdi      # 0x20089
xorl %eax, %eax
callq 0x6050
callq 0x6470
movq %rsp, %rdx
movl %eax, %edi
movl %ebx, %esi
callq 0x16d20
testl %eax, %eax
je 0x16e33
leaq 0x9257(%rip), %rdi      # 0x2007f
movl %eax, %esi
xorl %eax, %eax
callq 0x6050
jmp 0x16e45
movq (%rsp), %rsi
leaq 0x924b(%rip), %rdi      # 0x20089
xorl %eax, %eax
callq 0x6050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x91ed(%rip), %rdi      # 0x20042
leaq 0x9181(%rip), %rsi      # 0x1ffdd
leaq 0x91e9(%rip), %rcx      # 0x2004c
movl $0x6a, %edx
callq 0x6210
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16e9a
movq 0x11144(%rip), %rax     # 0x27fc8
movq (%rax), %rdi
leaq 0x9206(%rip), %rsi      # 0x20094
xorl %eax, %eax
callq 0x6490
callq 0x61b0
movl %ecx, %eax
movq 0x11125(%rip), %rcx     # 0x27fc8
movq (%rcx), %rdi
leaq 0x92b7(%rip), %rsi      # 0x20164
movslq (%rsi,%rax,4), %rcx
addq %rsi, %rcx
leaq 0x9235(%rip), %rsi      # 0x200f0
xorl %eax, %eax
callq 0x6490
callq 0x61b0
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2b72
movl 0x10(%rbx), %esi
testl %esi, %esi
jle 0x2b6d
decl %esi
movq %rbx, %rdi
callq 0x6596
movl 0x10(%rbx), %esi
testl %esi, %esi
jg 0x2b58
movq 0x8(%rbx), %rdi
callq 0x2180
movq (%rbx), %rax
testq %rax, %rax
je 0x2bb4
movq 0xa0(%rax), %rdi
callq 0x2180
movq (%rbx), %rax
movq 0xa8(%rax), %rdi
callq 0x2180
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
callq 0x2180
movq (%rbx), %rdi
callq 0x6fc0
movq (%rbx), %rdi
callq 0x2180
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x2bdd
movq 0x8(%rax), %rdi
callq 0x2180
movq 0x20(%rbx), %rax
movq 0x38(%rax), %rdi
callq 0x2180
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x2180
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
cmpb $0x0, (%rdx)
je 0x2f40
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %rbp
movq 0x90(%rdi), %r12
testq %r12, %r12
je 0x2e9d
movq %r12, %r14
movq (%r14), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x21c0
testl %eax, %eax
je 0x2ebc
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x2e82
movl $0x28, %edi
callq 0x2190
movq %rax, %r14
movq %r12, 0x20(%rax)
movq %rax, 0x90(%rbp)
movq 0x10(%rsp), %r12
jmp 0x2ee6
movq 0x8(%r14), %rdi
movq 0x10(%rsp), %r12
movq %r12, %rsi
callq 0x21c0
testl %eax, %eax
jne 0x2f58
movq %r15, %rdi
callq 0x2180
movq 0x8(%r14), %rdi
callq 0x2180
movq %r13, (%r14)
movq %r12, 0x8(%r14)
movl 0x8(%rsp), %eax
movb %al, 0x10(%r14)
movl 0xc(%rsp), %eax
movb %al, 0x11(%r14)
movq %rbx, %rdi
callq 0x2070
cmpq $0x3, %rax
jne 0x2f4c
movsbl (%rbx), %edi
callq 0x2fe8
movl %eax, 0x14(%r14)
movsbl 0x1(%rbx), %edi
callq 0x2fe8
movl %eax, 0x18(%r14)
movsbl 0x2(%rbx), %edi
callq 0x2fe8
movl %eax, 0x1c(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5641(%rip), %rdi      # 0x8588
callq 0x2fa0
leaq 0x569a(%rip), %rdi      # 0x85ed
callq 0x2fa0
leaq 0x565a(%rip), %rdi      # 0x85b9
callq 0x2fa0
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::parse_comment_specif(char)
int parse_comment_specif(char c) {
        switch (c) {
        case 'I':
        case 'i':
            return FLAG_IGNORE;
        case 'c':
            return FLAG_COMMENT;
        case 's':
            return FLAG_STRING;
        case 'q':
            return OUTPUT_TEXT;
        case 'S':
            return FLAG_STRING | PARSE_MACROS;
        case 'Q':
            return OUTPUT_TEXT | PARSE_MACROS;
        case 'C':
            return FLAG_COMMENT | PARSE_MACROS;
        default:
            bug("invalid comment/string modifier");
            return 0;
        }
    }

// Assembly:
movl $0x40, %eax
cmpl $0x62, %edi
jg 0x3002
cmpl $0x50, %edi
jg 0x3013
cmpl $0x43, %edi
je 0x3033
cmpl $0x49, %edi
jne 0x3048
retq
cmpl $0x70, %edi
jg 0x3023
cmpl $0x63, %edi
je 0x3039
cmpl $0x69, %edi
je 0x3001
jmp 0x3048
cmpl $0x51, %edi
je 0x303c
cmpl $0x53, %edi
jne 0x3048
movl $0x7, %eax
retq
cmpl $0x71, %edi
je 0x3042
cmpl $0x73, %edi
jne 0x3048
movl $0x3, %eax
retq
movl $0x4, %eax
retq
xorl %eax, %eax
retq
movl $0x5, %eax
retq
movl $0x1, %eax
retq
pushq %rax
leaq 0x559d(%rip), %rdi      # 0x85ed
callq 0x2fa0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movl %r9d, 0x10(%rsp)
movl %r8d, %ebx
movl %ecx, %r13d
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movl %r8d, %esi
callq 0x60f8
movl %eax, %ebp
leaq 0xc(%rsp), %rdx
movl %ebx, (%rdx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5bdc
testl %eax, %eax
je 0x5b5b
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, 0x14(%rsp)
movl 0x10(%rsp), %r14d
testb %bpl, %bpl
je 0x5bd0
cmpb %r13b, %bpl
movl %r14d, %ecx
jne 0x5b7e
cmpw $0x2, 0x18(%r12)
jge 0x5bc6
xorl %r13d, %r13d
movl $0x2, %eax
cmpb 0x14(%rsp), %bpl
je 0x5b9e
testb $0x4, %cl
je 0x5b99
movq (%r12), %rcx
cmpb 0x30(%rcx), %bpl
je 0x5b9e
movl $0x1, %eax
addl %eax, %ebx
movq %r12, %rdi
movl %ebx, %esi
callq 0x60f8
movl %eax, %ebp
movl %ebx, 0xc(%rsp)
movq %r12, %rdi
movq %r15, %rsi
leaq 0xc(%rsp), %rdx
callq 0x5bdc
testl %eax, %eax
je 0x5b65
jmp 0x5b4a
callq 0x22ff
movl %r14d, %ecx
jmp 0x5b7b
leaq 0x2a36(%rip), %rdi      # 0x860d
callq 0x2fa0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5c1a
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %esi
callq 0x60f8
testb %al, %al
jne 0x5c07
cmpb $0xa, (%r14)
jne 0x5c07
cmpb $0x0, 0x1(%r14)
je 0x5c1a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x5e70
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movslq 0xf0(%rdi), %rax
cmpl $0x0, 0x28(%rdi,%rax,4)
setne %al
testl %edx, %edx
setle %cl
orb %al, %cl
jne 0x5c90
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testl %ebx, %ebx
je 0x5c72
movslq %r12d, %rax
movb (%r14,%rax), %al
testb %al, %al
je 0x5c72
movq (%r15), %rcx
cmpb 0x30(%rcx), %al
jne 0x5c72
incl %r12d
cmpl %ebp, %r12d
je 0x5c90
movslq %r12d, %rax
movb (%r14,%rax), %al
testb %al, %al
je 0x5c88
movsbl %al, %esi
movq %r15, %rdi
callq 0x62b4
incl %r12d
cmpl %ebp, %r12d
jl 0x5c53
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5dbd
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 0x2190
movq %rax, %r14
movb $0xa, (%rax)
leaq 0x1(%rax), %rdi
movslq %r12d, %r12
movq %r13, %rsi
movq %r12, %rdx
callq 0x2100
movb $0x0, 0x1(%r14,%r12)
incq %r12
movq 0x20(%r15), %rbx
movl $0x50, %edi
callq 0x2190
movq %rax, %r13
movq %rax, 0x20(%r15)
movl $0x20, %edi
callq 0x2190
movq %rax, %rbp
movq %rax, 0x38(%r13)
xorl %eax, %eax
movl %eax, 0x1c(%r13)
movl 0x20(%rbx), %eax
movl %eax, 0x20(%r13)
movl $0x50, %edi
callq 0x2190
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)
xorl %eax, %eax
movl %eax, 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 0x3056
movq %r15, %rdi
xorl %esi, %esi
callq 0x62b4
movq 0x20(%r15), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %r14
callq 0x2180
movq 0x20(%r15), %rdi
callq 0x2180
movq %rbx, 0x20(%r15)
jmp 0x5dcd
movl $0x1, %edi
callq 0x2190
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_O3/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 0x5e6f
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
movl 0x10(%rcx), %eax
cmpl %esi, %eax
jge 0x5e01
movl $0x0, 0x10(%rcx)
jmp 0x5e4b
decl %esi
subl %esi, %eax
movl %esi, %edx
cmpl $0x64, %eax
jle 0x5e14
addq %rdx, (%rcx)
subl %esi, 0x14(%rcx)
jmp 0x5e34
xorl %edi, %edi
movq (%rcx), %rax
movb (%rax,%rdx), %cl
movb %cl, (%rax,%rdi)
incq %rdx
movq 0x20(%rbx), %rcx
movslq 0x10(%rcx), %rax
incq %rdi
cmpq %rax, %rdx
jl 0x5e16
subl %esi, %eax
movl %eax, 0x10(%rcx)
movq (%rcx), %rdx
xorl %esi, %esi
cmpb $0x0, (%rdx)
sete %sil
movl %esi, 0x40(%rcx)
cmpl $0x1, %eax
jg 0x5e6e
cmpl $0x0, 0x1c(%rcx)
je 0x5e66
movq 0x6158(%rip), %rax      # 0xbfb0
movq (%rax), %rdi
callq 0x2210
movq 0x20(%rbx), %rcx
jmp 0x5e6b
movl $0x1, %eax
movl %eax, 0x40(%rcx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x6051(%rip) # imm = 0xFFFFFD66
jne 0x612d
movq (%r14), %rax
movq 0x50(%rax), %rax
cmpb $0xa, (%rax)
jne 0x612d
cmpb $0x0, 0x1(%rax)
jne 0x612d
movl $0xa, 0x6033(%rip)      # 0xc160
movq 0x20(%r14), %r12
cmpl $0x0, 0x1c(%r12)
je 0x61d1
movl 0x14(%r12), %eax
cmpl %ebx, %eax
jg 0x6185
addl %ebx, %eax
movl %eax, 0x14(%r12)
movslq %eax, %rdi
callq 0x2190
movq %rax, %r15
movq (%r12), %rsi
movslq 0x10(%r12), %rdx
movq %rax, %rdi
callq 0x2100
movq 0x8(%r12), %rdi
callq 0x2180
movq 0x20(%r14), %r12
movq %r15, (%r12)
movq %r15, 0x8(%r12)
testq %r15, %r15
je 0x61ef
cmpl %ebx, 0x10(%r12)
jg 0x61d8
xorl %ebp, %ebp
callq 0x21a0
cmpl $0xd, %eax
je 0x618e
cmpl $0xa, 0x5fc1(%rip)      # 0xc160
movq 0x20(%r14), %rcx
jne 0x61a8
incl 0x18(%rcx)
movl %eax, 0x5fb2(%rip)      # 0xc160
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
cmpl %ebx, 0x10(%r12)
jle 0x618e
jmp 0x61d8
cmpl %ebx, 0x10(%r12)
jle 0x61eb
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 0x61e2
leaq 0x247c(%rip), %rdi      # 0x8672
callq 0x2fa0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14d
movq %rdi, %rbx
callq 0x60f8
testb %al, %al
je 0x625d
movq (%rbx), %rcx
cmpb 0x30(%rcx), %al
jne 0x6262
leal 0x1(%r14), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x60f8
testb %al, %al
je 0x62ad
movl %r14d, %ebp
addl $0x2, %ebp
cmpb $0x5f, %al
je 0x6251
leal -0x61(%rax), %ecx
cmpb $0x1a, %cl
jb 0x6251
leal -0x41(%rax), %ecx
cmpb $0x1a, %cl
jb 0x6251
testb %al, %al
js 0x6251
addb $-0x30, %al
cmpb $0x9, %al
ja 0x62ad
movq %rbx, %rdi
movl %ebp, %esi
callq 0x60f8
jmp 0x6265
movl %r14d, %ebp
jmp 0x62ad
movl %r14d, %ebp
cmpb $0x5f, %al
je 0x6283
leal -0x61(%rax), %ecx
cmpb $0x1a, %cl
jb 0x6283
leal -0x41(%rax), %ecx
cmpb $0x1a, %cl
jb 0x6283
testb %al, %al
js 0x6283
addb $-0x30, %al
cmpb $0x9, %al
ja 0x62ad
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x60f8
cmpb $0x5f, %al
je 0x6283
leal -0x61(%rax), %ecx
cmpb $0x1a, %cl
jb 0x6283
leal -0x41(%rax), %ecx
cmpb $0x1a, %cl
jb 0x6283
testb %al, %al
js 0x6283
addb $-0x30, %al
cmpb $0xa, %al
jb 0x6283
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x62fe
movq %rdi, %r14
movl 0x8(%rcx), %edx
leal 0x1(%rdx), %edi
cmpl %esi, %edi
jne 0x6317
addq %rsi, %rsi
movl %esi, 0xc(%rcx)
movq (%rcx), %rdi
callq 0x2230
movq 0x20(%r14), %rcx
movq 0x38(%rcx), %rcx
movq %rax, (%rcx)
testq %rax, %rax
je 0x632b
movl 0x8(%rcx), %edx
leal 0x1(%rdx), %edi
jmp 0x631a
cmpb $0xd, %bl
je 0x6323
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 0x2340(%rip), %rdi      # 0x8672
callq 0x2fa0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rdi
callq 0x2070
movq %rax, %rcx
xorl %eax, %eax
cmpl %ebp, %ecx
jne 0x6377
movl $0x1, %eax
testl %ebp, %ebp
jle 0x6377
movl %ebp, %ecx
xorl %edx, %edx
movb (%r14,%rdx), %sil
cmpb (%rbx,%rdx), %sil
jne 0x6375
incq %rdx
cmpq %rdx, %rcx
jne 0x6361
jmp 0x6377
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::delete_comment((anonymous namespace)::Specs*, char*)
void delete_comment(Specs *S, char *start) {
        Comment *p, *q;

        q = nullptr;
        for (p = S->comments; p != nullptr ; p = p->next) {
            if (!strcmp(p->start, start)) {
                if (q == nullptr )
                    S->comments = p->next;
                else
                    q->next = p->next;
                free(p->start);
                free(p->end);
                free(p);
                free(start);
                return;
            } else
                q = p;
        }
        free(start);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x90(%rdi), %r14
testq %r14, %r14
je 0x6403
movq %rdi, %r15
movq (%r14), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x21c0
testl %eax, %eax
je 0x63cf
movq %r14, %r13
movq 0x20(%r13), %r14
testq %r14, %r14
je 0x6403
movq (%r14), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x21c0
movq %r13, %rcx
movq %r14, %r13
testl %eax, %eax
jne 0x63ac
jmp 0x63d1
xorl %ecx, %ecx
addq $0x90, %r15
leaq 0x20(%rcx), %rax
testq %rcx, %rcx
movq 0x20(%r14), %rcx
cmoveq %r15, %rax
movq %rcx, (%rax)
movq %r12, %rdi
callq 0x2180
movq 0x8(%r14), %rdi
callq 0x2180
movq %r14, %rdi
callq 0x2180
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2180
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::comment_or_white(int, int, int)
int comment_or_white(int start, int end, int cmtmode) {
            char c;

            while (start < end) {
                skip_possible_comments(&start, cmtmode, 1);
                if (start < end) {
                    c = get_char(start++);
                    if ((c != ' ') && (c != '\n') && (c != '\t'))
                        return 0;
                }
            }
            return 1;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
movl $0x1, %eax
cmpl %edx, %esi
jge 0x6489
movl %edx, %ebx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movabsq $0x100000600, %r12      # imm = 0x100000600
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x6f00
movl 0xc(%rsp), %esi
cmpl %ebx, %esi
jge 0x647e
leal 0x1(%rsi), %ebp
movl %ebp, 0xc(%rsp)
movq %r14, %rdi
callq 0x60f8
movl %eax, %ecx
xorl %eax, %eax
cmpb $0x20, %cl
ja 0x6489
movzbl %cl, %ecx
btq %rcx, %r12
jb 0x6480
jmp 0x6489
movl %esi, %ebp
cmpl %ebx, %ebp
jl 0x6441
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::whiteout(int*, int*)
int whiteout(int *pos1, int *pos2) // remove whitespace on both sides
        {
            while ((*pos1 < *pos2) && is_white(get_char(*pos1)))
                (*pos1)++;
            while ((*pos1 < *pos2) && is_white(get_char(*pos2 - 1)))
                (*pos2)--;
            return (*pos1 < *pos2);
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %eax
movl (%rdx), %esi
movabsq $0x100000600, %r12      # imm = 0x100000600
cmpl %esi, %eax
jge 0x64e1
movq %r15, %rdi
movl %eax, %esi
callq 0x60f8
cmpb $0x20, %al
ja 0x64dc
movzbl %al, %eax
btq %rax, %r12
jae 0x64dc
movl (%r14), %eax
incl %eax
movl %eax, (%r14)
movl (%rbx), %esi
jmp 0x64b5
movl (%r14), %eax
movl (%rbx), %esi
cmpl %esi, %eax
jge 0x6507
decl %esi
movq %r15, %rdi
callq 0x60f8
cmpb $0x20, %al
ja 0x6507
movzbl %al, %eax
btq %rax, %r12
jae 0x6507
movl (%rbx), %esi
decl %esi
movl %esi, (%rbx)
cmpl %esi, (%r14)
jl 0x64e5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::find_ident(char const*, int)
int find_ident(const char *b, int l) {
            int i;

            for (i = 0; i < nmacros; i++)
                if (id_equal(b, l, macros[i].username))
                    return i;
            return -1;
        }

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %esi, %esi
jle 0x6595
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %r15
movl %ecx, %ebx
movl %esi, %eax
movq %rax, (%rsp)
xorl %r13d, %r13d
leaq (,%r13,2), %rax
addq %r13, %rax
shlq $0x4, %rax
movq (%r15,%rax), %r12
movq %r12, %rdi
callq 0x2070
cmpl %ebp, %eax
jne 0x6574
testl %ebp, %ebp
jle 0x6584
xorl %eax, %eax
movb (%r14,%rax), %cl
cmpb (%r12,%rax), %cl
jne 0x6574
incq %rax
cmpq %rax, %rbx
jne 0x6560
jmp 0x6584
incq %r13
cmpq (%rsp), %r13
jne 0x653b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x6587
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::delete_macro(int)
void delete_macro(int i) {
            int j;
            nmacros--;
            free(macros[i].username);
            free(macros[i].macrotext);
            if (macros[i].argnames != nullptr ) {
                for (j = 0; j < macros[i].nnamedargs; j++)
                    free(macros[i].argnames[j]);
                free(macros[i].argnames);
                macros[i].argnames = nullptr;
            }
            free_comments(macros[i].define_specs);
            free(macros[i].define_specs);
            memcpy(macros + i, macros + nmacros, sizeof(Macro));
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl 0x10(%rdi)
movq 0x8(%rdi), %rax
movl %esi, %r15d
movq %r15, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %r14
movq (%rax,%r14), %rdi
callq 0x2180
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r14), %rdi
callq 0x2180
movq 0x8(%rbx), %rax
movq 0x10(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x6624
leaq (%r15,%r15,2), %r15
shlq $0x4, %r15
cmpl $0x0, 0x1c(%rax,%r15)
jle 0x6612
xorl %r12d, %r12d
movq 0x10(%rax,%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x2180
incq %r12
movq 0x8(%rbx), %rax
movslq 0x1c(%rax,%r14), %rcx
cmpq %rcx, %r12
jl 0x65ee
movq 0x10(%rax,%r15), %rdi
callq 0x2180
movq 0x8(%rbx), %rax
movq $0x0, 0x10(%rax,%r15)
movq 0x20(%rax,%r14), %rdi
callq 0x6fc0
movq 0x8(%rbx), %rax
movq 0x20(%rax,%r14), %rdi
callq 0x2180
movq 0x8(%rbx), %rax
movslq 0x10(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movups (%rax,%rcx), %xmm0
movups 0x10(%rax,%rcx), %xmm1
movups 0x20(%rax,%rcx), %xmm2
movups %xmm2, 0x20(%rax,%r14)
movups %xmm1, 0x10(%rax,%r14)
movups %xmm0, (%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop