LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/travisdowns[P]avx-turbo/./args.hxx
// Function: args::ValueReader<unsigned long>::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
bool operator ()(const std::string &name, const std::string &value, T &destination)
        {
            std::istringstream ss(value);
            ss >> destination;

            if (ss.rdbuf()->in_avail() > 0)
            {
#ifdef ARGS_NOEXCEPT
                return false;
#else
                std::ostringstream problem;
                problem << "Argument '" << name << "' received invalid value type '" << value << "'";
                throw ParseError(problem.str());
#endif
            }
            return true;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x320, %rsp            # imm = 0x320
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x65a0
movq %r12, %rdi
movq %r15, %rsi
callq 0x6190
movq 0x50(%rsp), %rax
subq 0x48(%rsp), %rax
jne 0x13855
leaq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
jg 0x1388a
movq 0x1473f(%rip), %rsi     # 0x27fa0
leaq 0x28(%rsp), %rdi
callq 0x6480
leaq 0xa0(%rsp), %rdi
callq 0x60d0
movb $0x1, %al
addq $0x320, %rsp            # imm = 0x320
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a8(%rsp), %rdi
callq 0x6460
leaq 0xbec6(%rip), %rsi      # 0x1f764
leaq 0x1a8(%rsp), %rdi
movl $0xa, %edx
callq 0x63a0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x1a8(%rsp), %rdi
callq 0x63a0
movq %rax, %r14
leaq 0xbea1(%rip), %rsi      # 0x1f76f
movl $0x1f, %edx
movq %rax, %rdi
callq 0x63a0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x63a0
leaq 0xbdd0(%rip), %rsi      # 0x1f6c1
movl $0x1, %edx
movq %rax, %rdi
callq 0x63a0
movl $0x10, %edi
callq 0x6150
movq %rax, %r14
leaq 0x1b0(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6540
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6410
leaq 0x1414c(%rip), %rax     # 0x27a80
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x13da0(%rip), %rsi     # 0x276e0
movq 0x14671(%rip), %rdx     # 0x27fb8
movq %r14, %rdi
callq 0x65d0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1396d
callq 0x6320
jmp 0x1396d
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1397f
movq %r14, %rdi
callq 0x6260
jmp 0x1397f
movq %rax, %rbx
movq 0x1462a(%rip), %rsi     # 0x27fb0
leaq 0x1a8(%rsp), %rdi
callq 0x6170
leaq 0x218(%rsp), %rdi
callq 0x60d0
jmp 0x139a7
jmp 0x139a4
movq %rax, %rbx
movq 0x145f2(%rip), %rsi     # 0x27fa0
leaq 0x28(%rsp), %rdi
callq 0x6480
leaq 0xa0(%rsp), %rdi
callq 0x60d0
movq %rbx, %rdi
callq 0x65f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/travisdowns[P]avx-turbo/./table.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> table::string_format<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double)
std::string string_format(const std::string& format, Args ... args) {
    size_t size = snprintf( nullptr, 0, format.c_str(), args ... ) + 1; // Extra space for '\0'
    std::unique_ptr<char[]> buf( new char[ size ] );
    snprintf( buf.get(), size, format.c_str(), args ... );
    return std::string( buf.get(), buf.get() + size - 1 ); // We don't want the '\0' inside
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdx
xorl %edi, %edi
xorl %esi, %esi
movb $0x1, %al
callq 0x6550
movslq %eax, %r13
leaq 0x1(%r13), %r12
movq %r12, %rdi
callq 0x6030
movq %rax, %r14
movq (%r15), %rdx
movq %rax, %rdi
movq %r12, %rsi
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x6550
leaq (%r14,%r13), %rdx
incq %rdx
decq %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12eaa
movq %r14, %rdi
callq 0x6430
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x6430
movq %rbx, %rdi
callq 0x65f0
// File: /workspace/github_cpp_makefile_star2_O1/travisdowns[P]avx-turbo/avx-turbo.cpp
// Function: test_thread::operator()()
void operator()() {
        // if (verbose) printf("Running test in thread %lu, this = %p\n", id, this);
        if (!arg_no_pin) {
            pin_to_cpu(id);
        }
        aperf_ghz aperf_timer;
        outer_timer& outer = use_aperf ? static_cast<outer_timer&>(aperf_timer) : dummy_outer::dummy;
        warmup w{arg_warm_ms.Get()};
        long warms = w.warm();
        if (verbose) printf("[%2lu] Warmup iters %lu\n", id, warms);
        if (!arg_nobarrier) {
            long count = start_barrier->wait();
            if (verbose) printf("[%2lu] Thread loop count: %ld\n", id, count);
        }
        res.start_ts = RdtscClock::now();
        res.inner = run_test<RdtscClock>(test->func, iters, outer, stop_barrier);
        res.end_ts = RdtscClock::now();
        res.aperf_am   = use_aperf ? aperf_timer.am_ratio() : 0.0;
        res.aperf_mt   = use_aperf ? aperf_timer.mt_ratio() : 0.0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x13fe3(%rip), %rax     # 0x286a0
leaq 0x13fdc(%rip), %rdi     # 0x286a0
callq *0x10(%rax)
testb %al, %al
jne 0x146d2
movl (%rbx), %edi
callq 0x802a
leaq 0x13667(%rip), %rax     # 0x27d40
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rcx)
movq $0x0, 0x18(%rcx)
movl $0x1, 0x20(%rcx)
leaq 0x13c3a(%rip), %r14     # 0x28338
cmpb $0x0, 0x70(%rbx)
cmovneq %rcx, %r14
movq 0x14afb(%rip), %rax     # 0x29208
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x14820
cmpb $0x1, 0x14af7(%rip)     # 0x29218
jne 0x14737
movq (%rbx), %rsi
leaq 0xb062(%rip), %rdi      # 0x1f78f
movq %rax, %rdx
xorl %eax, %eax
callq 0x6050
movq 0x140f2(%rip), %rax     # 0x28830
leaq 0x140eb(%rip), %rdi     # 0x28830
callq *0x10(%rax)
testb %al, %al
jne 0x14782
movq 0x8(%rbx), %rax
lock
incq 0x8(%rax)
movq $-0x1, %rdx
movq 0x8(%rax), %rcx
incq %rdx
cmpq (%rax), %rcx
jne 0x1475c
cmpb $0x1, 0x14aa9(%rip)     # 0x29218
jne 0x14782
movq (%rbx), %rsi
leaq 0xb02d(%rip), %rdi      # 0x1f7a8
xorl %eax, %eax
callq 0x6050
lfence
rdtsc
shlq $0x20, %rdx
orq %rax, %rdx
lfence
movq %rdx, 0x40(%rbx)
movq 0x10(%rbx), %r8
movq 0x60(%rbx), %rax
movq (%rax), %rsi
movq 0x68(%rbx), %rdx
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
callq 0x14873
movq 0x20(%r15), %rax
movq %rax, 0x38(%rbx)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x28(%rbx)
movups %xmm0, 0x18(%rbx)
lfence
rdtsc
shlq $0x20, %rdx
orq %rax, %rdx
lfence
movq %rdx, 0x48(%rbx)
xorps %xmm1, %xmm1
cmpb $0x1, 0x70(%rbx)
xorps %xmm0, %xmm0
jne 0x147f9
leaq 0x10(%rsp), %rdi
callq 0x14ad0
xorps %xmm1, %xmm1
movsd %xmm0, 0x50(%rbx)
cmpb $0x1, 0x70(%rbx)
jne 0x14811
leaq 0x10(%rsp), %rdi
callq 0x14b70
movaps %xmm0, %xmm1
movsd %xmm1, 0x58(%rbx)
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/travisdowns[P]avx-turbo/avx-turbo.cpp
// Function: warmup::warm()
long warm() {
        int64_t start = (int64_t)RdtscClock::now();
        long iters = 0;
        while (RdtscClock::to_nanos(RdtscClock::now() - start) < 1000000u * millis) {
            iters++;
        }
        return iters;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
lfence
rdtsc
movq %rdx, %r14
shlq $0x20, %r14
orq %rax, %r14
lfence
movq $-0x1, %r15
lfence
rdtsc
movq %rdx, %rdi
shlq $0x20, %rdi
orq %rax, %rdi
lfence
subq %r14, %rdi
callq 0x14d16
imulq $0xf4240, (%rbx), %rcx  # imm = 0xF4240
incq %r15
cmpq %rcx, %rax
jb 0x14841
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/travisdowns[P]avx-turbo/avx-turbo.cpp
// Function: aperf_ghz::am_ratio()
double am_ratio() {
        assert(state == STOPPED);
        assert(mperf_value != 0 && aperf_value != 0);
//        printf("timer ratio m: %lu (delta)\n", mperf_value);
//        printf("timer ratio a: %lu (delta)\n", aperf_value);
        return (double)aperf_value / mperf_value;
    }

// Assembly:
pushq %rax
cmpl $0x1, 0x20(%rdi)
jne 0x14b50
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x14b31
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x14b31
movq %rcx, %xmm1
movq 0x953a(%rip), %xmm2     # 0x1e030
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x953e(%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 0xade8(%rip), %rdi      # 0x1f920
leaq 0x9b39(%rip), %rsi      # 0x1e678
leaq 0xadbd(%rip), %rcx      # 0x1f903
movl $0x135, %edx            # imm = 0x135
callq 0x6210
leaq 0xac70(%rip), %rdi      # 0x1f7c7
leaq 0x9b1a(%rip), %rsi      # 0x1e678
leaq 0xad9e(%rip), %rcx      # 0x1f903
movl $0x134, %edx            # imm = 0x134
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14bf0
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x14bd1
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x14bd1
movq %rcx, %xmm1
movq 0x949a(%rip), %xmm2     # 0x1e030
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x949e(%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 0xad8a(%rip), %rdi      # 0x1f962
leaq 0x9a99(%rip), %rsi      # 0x1e678
leaq 0xad5f(%rip), %rcx      # 0x1f945
movl $0x13e, %edx            # imm = 0x13E
callq 0x6210
leaq 0xabd0(%rip), %rdi      # 0x1f7c7
leaq 0x9a7a(%rip), %rsi      # 0x1e678
leaq 0xad40(%rip), %rcx      # 0x1f945
movl $0x13d, %edx            # imm = 0x13D
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14c4e
movq %rdi, %rbx
movl $0x0, 0x20(%rdi)
movl $0xe7, %edi
callq 0x14cdc
movq %rax, 0x8(%rbx)
movl $0xe8, %edi
callq 0x14cdc
movq %rax, 0x10(%rbx)
rdtsc
shlq $0x20, %rdx
orq %rax, %rdx
movq %rdx, 0x18(%rbx)
popq %rbx
retq
leaq 0xab72(%rip), %rdi      # 0x1f7c7
leaq 0x9a1c(%rip), %rsi      # 0x1e678
leaq 0xab75(%rip), %rcx      # 0x1f7d8
movl $0x11f, %edx            # imm = 0x11F
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14cb6
movq %rdi, %rbx
movl $0xe7, %edi
callq 0x14cdc
subq 0x8(%rbx), %rax
movq %rax, 0x8(%rbx)
movl $0xe8, %edi
callq 0x14cdc
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 0xab6e(%rip), %rdi      # 0x1f82b
leaq 0x99b4(%rip), %rsi      # 0x1e678
leaq 0xab71(%rip), %rcx      # 0x1f83c
movl $0x129, %edx            # imm = 0x129
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1701d
testl %eax, %eax
jne 0x14cf6
movq (%rsp), %rax
popq %rcx
retq
leaq 0xaafb(%rip), %rdi      # 0x1f7f8
leaq 0x9974(%rip), %rsi      # 0x1e678
leaq 0xaaf6(%rip), %rcx      # 0x1f801
movl $0x111, %edx            # imm = 0x111
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14e56
xorpd %xmm5, %xmm5
movsd 0x92a5(%rip), %xmm2     # 0x1e0a0
movsd 0x9295(%rip), %xmm3     # 0x1e098
xorl %r14d, %r14d
movsd 0x9222(%rip), %xmm0     # 0x1e030
movapd 0x922a(%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 0x14e19
jmp 0x14e6d
movsd 0x923a(%rip), %xmm4     # 0x1e098
movsd 0x923a(%rip), %xmm6     # 0x1e0a0
xorpd %xmm5, %xmm5
xorl %r14d, %r14d
movapd %xmm4, 0x10(%rsp)
movapd %xmm6, 0x20(%rsp)
movq %r14, %xmm0
punpckldq 0x91aa(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x91b2(%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 0x14f02
movq %rax, %xmm0
punpckldq 0x9174(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x917c(%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_O1/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 0x14fa6
movq %rdi, %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x15004
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x14f63
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 0x150c8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x151b1
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
subq %rdi, %rcx
movq %rcx, %rax
sarq $0x3, %rax
shrq %rax
testb $0x8, %cl
jne 0x14f8d
movq (%rdi,%rax,8), %rbx
addq -0x8(%rdi,%rax,8), %rbx
shrq %rbx
jmp 0x14f91
movq (%rdi,%rax,8), %rbx
testq %rdi, %rdi
je 0x14f9b
callq 0x6320
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x6150
movq %rax, %r14
leaq 0xa929(%rip), %rsi      # 0x1f8e3
movq %rax, %rdi
callq 0x64a0
movq 0x1300f(%rip), %rsi     # 0x27fd8
movq 0x12ff0(%rip), %rdx     # 0x27fc0
movq %r14, %rdi
callq 0x65d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x6260
jmp 0x14ffc
movq %rax, %rbx
jmp 0x14ffc
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14ffc
callq 0x6320
movq %rbx, %rdi
callq 0x65f0
// File: /workspace/github_cpp_makefile_star2_O1/travisdowns[P]avx-turbo/cpuid.cpp
// Function: gfm_inner()
cpuid_result cpuid(int leaf, int subleaf) {
    cpuid_result ret = {};
    asm ("cpuid"
            :
            "=a" (ret.eax),
            "=b" (ret.ebx),
            "=c" (ret.ecx),
            "=d" (ret.edx)
            :
            "a" (leaf),
            "c" (subleaf)
    );
    return ret;
}

// Assembly:
pushq %rbx
movl $0x1, %eax
xorl %ecx, %ecx
cpuid
xorl %ecx, %ecx
movl %eax, %edx
shrl $0x8, %edx
andb $0xf, %dl
movl %eax, %esi
shrb $0x4, %sil
movl %eax, %edi
shrl $0x14, %edi
addb $0xf, %dil
cmpb $0xf, %dl
movzbl %dil, %edi
movzbl %dl, %edx
cmovel %edi, %edx
movl %eax, %edi
shrl $0xc, %edi
andb $-0x10, %dil
cmpb $0x6, %dl
movzbl %dil, %edi
cmovel %edi, %ecx
cmpb $0xf, %dl
cmovel %edi, %ecx
orb %sil, %cl
andb $0xf, %al
movzbl %al, %eax
shll $0x10, %eax
movzbl %cl, %ecx
shll $0x8, %ecx
orl %eax, %ecx
movzbl %dl, %eax
orl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15ec5
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpl $0xb, %eax
jae 0x16280
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 0x162b9
cmpl $-0x1, %esi
jne 0x162c4
andl $0x1f, %r14d
movl %r14d, %esi
andb %r15b, %bl
incl %ebp
testb %bl, %bl
jne 0x16282
jmp 0x16273
callq 0x67fd
jmp 0x162b2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15ec5
cmpl $0x14, %eax
ja 0x162ed
leaq 0x9c97(%rip), %rdi      # 0x1ff7b
callq 0x6500
xorl %eax, %eax
jmp 0x1634d
movl $0x15, %edi
callq 0x15eaa
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x15890
movq (%rbx), %rsi
leaq 0x9bad(%rip), %rdi      # 0x1fec7
xorl %eax, %eax
callq 0x6050
movq (%rbx), %rdi
leaq 0x28(%rsp), %r14
cmpq %r14, %rdi
je 0x16333
callq 0x6320
movl 0x10(%rsp), %ecx
testq %rcx, %rcx
je 0x16355
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 0x15f60
leaq 0x4(%rsp), %rsi
movw %ax, (%rsi)
shrl $0x10, %eax
movb %al, 0x2(%rsi)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x165cc
movq (%rbx), %rsi
leaq 0x9b54(%rip), %rdi      # 0x1fed3
xorl %eax, %eax
callq 0x6050
movq (%rbx), %rdi
cmpq %r14, %rdi
je 0x16393
callq 0x6320
cmpb $0x6, 0x4(%rsp)
jne 0x163b5
movzbl 0x5(%rsp), %ecx
xorl %eax, %eax
cmpl $0x8d, %ecx
jg 0x163c1
cmpl $0x4e, %ecx
je 0x163d5
cmpl $0x5e, %ecx
je 0x163d5
jmp 0x1634d
leaq 0x9b6a(%rip), %rdi      # 0x1ff26
jmp 0x162e4
cmpl $0x9e, %ecx
je 0x163d5
cmpl $0x8e, %ecx
jne 0x1634d
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %eax
imulq $0x16e3600, %rax, %rax  # imm = 0x16E3600
xorl %edx, %edx
divq %rcx
jmp 0x1634d
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x18, %rsp
lfence
leaq 0x8(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x6310
imulq $0x3b9aca00, (%r14), %rcx # imm = 0x3B9ACA00
movq 0x8(%r14), %rsi
leaq (%rcx,%rsi), %r15
rdtsc
movq %rdx, %rbx
shlq $0x20, %rbx
orq %rax, %rbx
leaq (%rcx,%rsi), %r12
addq $0x2710, %r12           # imm = 0x2710
movl $0x1, %edi
movq %r14, %rsi
callq 0x6310
imulq $0x3b9aca00, 0x8(%rsp), %rax # imm = 0x3B9ACA00
addq 0x10(%rsp), %rax
cmpq %rax, %r12
ja 0x16489
leaq 0x8(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x6310
imulq $0x3b9aca00, (%r14), %rcx # imm = 0x3B9ACA00
movq 0x8(%r14), %rsi
rdtsc
shlq $0x20, %rdx
orq %rax, %rdx
subq %rbx, %rdx
imulq $0x3b9aca00, %rdx, %rax # imm = 0x3B9ACA00
subq %r15, %rsi
addq %rcx, %rsi
xorl %edx, %edx
divq %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16443
movq %rax, 0x328(%rsp,%rbx,8)
incq %rbx
cmpq $0xca, %rbx
jne 0x164fc
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 0x169df
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16ac6
movl $0x140, %ecx            # imm = 0x140
xorl %eax, %eax
addq (%rsp,%rcx), %rax
addq $0x8, %rcx
cmpq $0x1e0, %rcx            # imm = 0x1E0
jne 0x1655a
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_O1/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 0x16e1e
addq $0x4, %r14
callq 0x16d50
testl %eax, %eax
je 0x16e1c
movl (%r14), %edi
addq $0x4, %r14
testl %edi, %edi
jne 0x16e06
jmp 0x16e1e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
testl %edi, %edi
js 0x16f84
movl %edi, %ebx
leaq 0x12482(%rip), %rdi     # 0x29310
callq 0x64c0
movslq 0x114be(%rip), %r15     # 0x28358
cmpl %ebx, %r15d
jg 0x16ef5
leal (%r15,%r15), %r14d
cmpl %ebx, %r14d
cmovlel %ebx, %r14d
movl $0x4, %esi
movq %r14, %rdi
callq 0x6220
movq %rax, %r12
movq 0x1149f(%rip), %r13     # 0x28360
shlq $0x2, %r15
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x62c0
leaq 0x12466(%rip), %rax     # 0x29340
cmpq %rax, %r13
je 0x16ee7
movq %r13, %rdi
callq 0x63d0
movq %r12, 0x11472(%rip)     # 0x28360
movl %r14d, 0x11463(%rip)    # 0x28358
movq 0x11464(%rip), %rax     # 0x28360
movl %ebx, %r14d
cmpl $0x0, (%rax,%r14,4)
jne 0x16f5d
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
leaq 0x90cb(%rip), %rdx      # 0x1ffed
movl $0x40, %esi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x6550
testl %eax, %eax
jle 0x16fa3
xorl %ebx, %ebx
movq %rsp, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x6270
movq 0x11417(%rip), %r15     # 0x28360
movl %eax, (%r15,%r14,4)
cmpl $-0x1, %eax
jne 0x16f5d
callq 0x6040
subl (%rax), %ebx
movl %ebx, (%r15,%r14,4)
movq 0x113fc(%rip), %rax     # 0x28360
movl (%rax,%r14,4), %ebx
leaq 0x123a1(%rip), %rdi     # 0x29310
callq 0x6290
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x9039(%rip), %rdi      # 0x1ffc4
leaq 0x903b(%rip), %rsi      # 0x1ffcd
leaq 0x9041(%rip), %rcx      # 0x1ffda
movl $0x36, %edx
callq 0x6210
leaq 0x9053(%rip), %rdi      # 0x1fffd
leaq 0x901c(%rip), %rsi      # 0x1ffcd
leaq 0x9022(%rip), %rcx      # 0x1ffda
movl $0x49, %edx
callq 0x6210
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16e70
testl %eax, %eax
je 0x16ffe
js 0x16ff7
movl %ebp, %ecx
movl $0x8, %edx
movl %eax, %edi
movq %rbx, %rsi
callq 0x6400
movq %rax, %rcx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x16ff7
callq 0x6040
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x9000(%rip), %rdi      # 0x20005
leaq 0x8fc1(%rip), %rsi      # 0x1ffcd
leaq 0x8ff7(%rip), %rcx      # 0x2000a
movl $0x59, %edx
callq 0x6210
// File: /workspace/github_cpp_makefile_star2_O1/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 0x170f0
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x6520
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x6520
movl %eax, %ebx
leaq 0x8feb(%rip), %rdi      # 0x20053
movl %eax, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x6050
movq %rsp, %rdx
movq $-0x1, (%rdx)
movl %ebp, %edi
movl %ebx, %esi
callq 0x16fc2
testl %eax, %eax
je 0x1709c
leaq 0x8fde(%rip), %rdi      # 0x2006f
movl %eax, %esi
xorl %eax, %eax
callq 0x6050
jmp 0x170ae
movq (%rsp), %rsi
leaq 0x8fd2(%rip), %rdi      # 0x20079
xorl %eax, %eax
callq 0x6050
callq 0x6470
movq %rsp, %rdx
movl %eax, %edi
movl %ebx, %esi
callq 0x16fc2
testl %eax, %eax
je 0x170d5
leaq 0x8fa5(%rip), %rdi      # 0x2006f
movl %eax, %esi
xorl %eax, %eax
callq 0x6050
jmp 0x170e7
movq (%rsp), %rsi
leaq 0x8f99(%rip), %rdi      # 0x20079
xorl %eax, %eax
callq 0x6050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8f3b(%rip), %rdi      # 0x20032
leaq 0x8ecf(%rip), %rsi      # 0x1ffcd
leaq 0x8f37(%rip), %rcx      # 0x2003c
movl $0x6a, %edx
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1713a
movq 0x10ea4(%rip), %rax     # 0x27fc8
movq (%rax), %rdi
leaq 0x8f56(%rip), %rsi      # 0x20084
xorl %eax, %eax
callq 0x6490
callq 0x61b0
movl %ecx, %eax
movq 0x10e85(%rip), %rcx     # 0x27fc8
movq (%rcx), %rdi
leaq 0x9007(%rip), %rsi      # 0x20154
movslq (%rsi,%rax,4), %rcx
addq %rsi, %rcx
leaq 0x8f85(%rip), %rsi      # 0x200e0
xorl %eax, %eax
callq 0x6490
callq 0x61b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b93
jmp 0x2ba3
decl %esi
movq %rbx, %rdi
callq 0x6574
movl 0x10(%rbx), %esi
testl %esi, %esi
jg 0x2b89
movq 0x8(%rbx), %rdi
callq 0x2170
movq (%rbx), %rax
testq %rax, %rax
je 0x2be5
movq 0xa0(%rax), %rdi
callq 0x2170
movq (%rbx), %rax
movq 0xa8(%rax), %rdi
callq 0x2170
movq (%rbx), %rax
movq 0xb0(%rax), %rdi
callq 0x2170
movq (%rbx), %rdi
callq 0x6f76
movq (%rbx), %rdi
callq 0x2170
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x2c0e
movq 0x8(%rax), %rdi
callq 0x2170
movq 0x20(%rbx), %rax
movq 0x38(%rax), %rdi
callq 0x2170
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x2170
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f62
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %rbp
movq 0x90(%rdi), %r14
testq %r14, %r14
je 0x2ec3
movq (%r14), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x21b0
testl %eax, %eax
je 0x2ee4
movq 0x20(%r14), %r14
jmp 0x2ea6
movl $0x28, %edi
callq 0x2180
movq %rax, %r14
movq 0x90(%rbp), %rax
movq %rax, 0x20(%r14)
movq %r14, 0x90(%rbp)
jmp 0x2f09
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x21b0
testl %eax, %eax
jne 0x2f7a
movq %r15, %rdi
callq 0x2170
movq 0x8(%r14), %rdi
callq 0x2170
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 0x2070
cmpq $0x3, %rax
jne 0x2f6e
movsbl (%rbx), %edi
callq 0x300c
movl %eax, 0x14(%r14)
movsbl 0x1(%rbx), %edi
callq 0x300c
movl %eax, 0x18(%r14)
movsbl 0x2(%rbx), %edi
callq 0x300c
movl %eax, 0x1c(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x567b(%rip), %rdi      # 0x85e4
callq 0x2fc4
leaq 0x56d4(%rip), %rdi      # 0x8649
callq 0x2fc4
leaq 0x5694(%rip), %rdi      # 0x8615
callq 0x2fc4
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3026
cmpl $0x50, %edi
jg 0x3037
cmpl $0x43, %edi
je 0x3057
cmpl $0x49, %edi
jne 0x306c
retq
cmpl $0x70, %edi
jg 0x3047
cmpl $0x63, %edi
je 0x305d
cmpl $0x69, %edi
je 0x3025
jmp 0x306c
cmpl $0x51, %edi
je 0x3060
cmpl $0x53, %edi
jne 0x306c
movl $0x7, %eax
retq
cmpl $0x71, %edi
je 0x3066
cmpl $0x73, %edi
jne 0x306c
movl $0x3, %eax
retq
movl $0x4, %eax
retq
xorl %eax, %eax
retq
movl $0x5, %eax
retq
movl $0x1, %eax
retq
pushq %rax
leaq 0x55d5(%rip), %rdi      # 0x8649
callq 0x2fc4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x60ce
movl %eax, %ebp
leaq 0xc(%rsp), %rdx
movl %ebx, (%rdx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5b98
testl %eax, %eax
je 0x5b17
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 0x5b8c
cmpb %r13b, %bpl
movl %r14d, %ecx
jne 0x5b3a
cmpw $0x2, 0x18(%r12)
jge 0x5b82
xorl %r13d, %r13d
movl $0x2, %eax
cmpb 0x14(%rsp), %bpl
je 0x5b5a
testb $0x4, %cl
je 0x5b55
movq (%r12), %rcx
cmpb 0x30(%rcx), %bpl
je 0x5b5a
movl $0x1, %eax
addl %eax, %ebx
movq %r12, %rdi
movl %ebx, %esi
callq 0x60ce
movl %eax, %ebp
movl %ebx, 0xc(%rsp)
movq %r12, %rdi
movq %r15, %rsi
leaq 0xc(%rsp), %rdx
callq 0x5b98
testl %eax, %eax
je 0x5b21
jmp 0x5b06
callq 0x2339
movl %r14d, %ecx
jmp 0x5b37
leaq 0x2ad6(%rip), %rdi      # 0x8669
callq 0x2fc4
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5bd6
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %esi
callq 0x60ce
testb %al, %al
jne 0x5bc3
cmpb $0xa, (%r14)
jne 0x5bc3
cmpb $0x0, 0x1(%r14)
je 0x5bd6
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x5e50
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c4c
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testl %ebx, %ebx
je 0x5c2e
movslq %r12d, %rax
movb (%r14,%rax), %al
testb %al, %al
je 0x5c2e
movq (%r15), %rcx
cmpb 0x30(%rcx), %al
jne 0x5c2e
incl %r12d
cmpl %ebp, %r12d
je 0x5c4c
movslq %r12d, %rax
movb (%r14,%rax), %al
testb %al, %al
je 0x5c44
movsbl %al, %esi
movq %r15, %rdi
callq 0x6294
incl %r12d
cmpl %ebp, %r12d
jl 0x5c0f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5d88
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 0x2180
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
movl $0x50, %edi
callq 0x2180
movq %rax, %r13
movq %rax, 0x20(%r15)
movl $0x20, %edi
callq 0x2180
movq %rax, %rbp
movq %rax, 0x38(%r13)
xorl %eax, %eax
movl %eax, 0x1c(%r13)
movl 0x20(%rbx), %eax
movl %eax, 0x20(%r13)
movq 0x28(%rbx), %rax
movq %rax, 0x28(%r13)
movl $0x50, %edi
callq 0x2180
movq %rax, (%rbp)
movabsq $0x5000000000, %rax     # imm = 0x5000000000
movq %rax, 0x8(%rbp)
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%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)
movq 0x30(%rbx), %rax
movq %rax, 0x30(%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 0x307a
movq %r15, %rdi
xorl %esi, %esi
callq 0x6294
movq 0x20(%r15), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %r14
callq 0x2170
movq 0x20(%r15), %rdi
callq 0x2170
movq %rbx, 0x20(%r15)
jmp 0x5d98
movl $0x1, %edi
callq 0x2180
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5e4e
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
movl 0x10(%rcx), %edx
cmpl %esi, %edx
jge 0x5dcb
movl $0x0, 0x10(%rcx)
jmp 0x5e20
leal -0x1(%rsi), %eax
subl %eax, %edx
cmpl $0x64, %edx
jle 0x5ddf
movl %eax, %edx
addq %rdx, (%rcx)
subl %eax, 0x14(%rcx)
jmp 0x5e0b
movq 0x20(%rbx), %rdx
cmpl %esi, 0x10(%rdx)
jl 0x5e0b
movslq %eax, %rcx
xorl %esi, %esi
movq (%rdx), %rdx
movb (%rdx,%rcx), %dil
movb %dil, (%rdx,%rsi)
incq %rcx
movq 0x20(%rbx), %rdx
movslq 0x10(%rdx), %rdi
incq %rsi
cmpq %rdi, %rcx
jl 0x5ded
movq 0x20(%rbx), %rcx
subl %eax, 0x10(%rcx)
movq (%rcx), %rax
xorl %edx, %edx
cmpb $0x0, (%rax)
sete %dl
movl %edx, 0x40(%rcx)
movq 0x20(%rbx), %rcx
cmpl $0x1, 0x10(%rcx)
jg 0x5e4d
cmpl $0x0, 0x1c(%rcx)
je 0x5e45
movq 0x6179(%rip), %rax      # 0xbfb0
movq (%rax), %rdi
callq 0x2200
movq 0x20(%rbx), %rcx
jmp 0x5e4a
movl $0x1, %eax
movl %eax, 0x40(%rcx)
popq %rbx
retq
nop