LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: travisdowns[P]avx-turbo/./args.hxx
// Function: args::Glyphs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline std::string::size_type Glyphs(const std::string &string_)
    {
        std::string::size_type length = 0;
        for (const char c: string_)
        {
            if ((c & 0xc0) != 0x80)
            {
                ++length;
            }
        }
        return length;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7440
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7820
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x24dc0
testb $0x1, %al
jne 0x27889
jmp 0x278c0
leaq -0x20(%rbp), %rdi
callq 0x24e30
movb (%rax), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
andl $0xc0, %eax
cmpl $0x80, %eax
je 0x278b3
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x278b5
leaq -0x20(%rbp), %rdi
callq 0x25110
jmp 0x27876
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x390, %rsp            # imm = 0x390
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x358(%rbp)
movl $0x8, %edx
callq 0x7770
movq -0x358(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7660
jmp 0x2d0c9
leaq -0x1a0(%rbp), %rdi
callq 0x7140
movq %rax, -0x360(%rbp)
jmp 0x2d0de
movq -0x360(%rbp), %rdi
callq 0x77e0
movq %rax, -0x368(%rbp)
jmp 0x2d0f3
movq -0x368(%rbp), %rax
cmpq $0x0, %rax
jle 0x2d27d
leaq -0x328(%rbp), %rdi
callq 0x7610
jmp 0x2d112
leaq 0x14715(%rip), %rsi     # 0x4182e
leaq -0x328(%rbp), %rdi
callq 0x7470
movq %rax, -0x370(%rbp)
jmp 0x2d12e
movq -0x370(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x73f0
movq %rax, -0x378(%rbp)
jmp 0x2d147
movq -0x378(%rbp), %rdi
leaq 0x146e4(%rip), %rsi     # 0x41839
callq 0x7470
movq %rax, -0x380(%rbp)
jmp 0x2d163
movq -0x380(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x73f0
movq %rax, -0x388(%rbp)
jmp 0x2d17c
movq -0x388(%rbp), %rdi
leaq 0x145d7(%rip), %rsi     # 0x41761
callq 0x7470
jmp 0x2d191
movb $0x1, -0x349(%rbp)
movl $0x10, %edi
callq 0x7210
movq %rax, -0x390(%rbp)
leaq -0x348(%rbp), %rdi
leaq -0x328(%rbp), %rsi
callq 0x7490
jmp 0x2d1be
movq -0x390(%rbp), %rdi
leaq -0x348(%rbp), %rsi
callq 0x25430
jmp 0x2d1d3
movq -0x390(%rbp), %rdi
movb $0x0, -0x349(%rbp)
leaq 0x2d458(%rip), %rsi     # 0x5a640
leaq -0x137af(%rip), %rdx    # 0x19a40
callq 0x7790
jmp 0x2d2ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x2d296
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x2d26f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x2d256
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x348(%rbp), %rdi
callq 0x7290
testb $0x1, -0x349(%rbp)
jne 0x2d261
jmp 0x2d26d
movq -0x390(%rbp), %rdi
callq 0x7350
jmp 0x2d26f
leaq -0x328(%rbp), %rdi
callq 0x70f0
jmp 0x2d296
leaq -0x1a0(%rbp), %rdi
callq 0x7200
movb $0x1, %al
andb $0x1, %al
addq $0x390, %rsp            # imm = 0x390
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x7200
movq -0x1a8(%rbp), %rdi
callq 0x77b0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x71a0
movq %rax, %rdx
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
movl %eax, %esi
movb $0x1, %al
movb %al, -0x69(%rbp)
movq %rsi, %rdi
callq 0x7710
incl %eax
cltq
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7030
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2f120
movq -0x68(%rbp), %rdi
callq 0x2f150
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x71a0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rax, %rdx
movb -0x69(%rbp), %al
movsd -0x18(%rbp), %xmm0
callq 0x7710
movq -0x68(%rbp), %rdi
callq 0x2f150
movq -0x68(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x2f150
movq -0x20(%rbp), %rcx
leaq -0x1(%rax,%rcx), %rax
movq %rax, -0x50(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x77c0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x2f180
jmp 0x2f0d6
leaq -0x29(%rbp), %rdi
callq 0x74d0
leaq -0x28(%rbp), %rdi
callq 0x2f1f0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x74d0
leaq -0x28(%rbp), %rdi
callq 0x2f1f0
movq -0x38(%rbp), %rdi
callq 0x77b0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x31e10
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x31e10
movq %rax, %rdi
subq -0x10(%rbp), %rdi
callq 0x32520
movq -0x20(%rbp), %rcx
imulq $0xf4240, (%rcx), %rcx  # imm = 0xF4240
cmpq %rcx, %rax
jae 0x31db4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x31d85
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: travisdowns[P]avx-turbo/avx-turbo.cpp
// Function: hot_barrier::wait()
long wait() {
        increment();
        long count = 0;
        while (!is_broken()) {
            count++;
        }
        return count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x32620
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x32650
xorb $-0x1, %al
testb $0x1, %al
jne 0x31df2
jmp 0x31e00
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x31de1
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: travisdowns[P]avx-turbo/avx-turbo.cpp
// Function: RdtscClock::now()
static now_t now() {
        _mm_lfence();
        now_t ret = rdtsc();
        _mm_lfence();
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
lfence
callq 0x105d0
movq %rax, -0x8(%rbp)
lfence
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x1, 0x20(%rax)
jne 0x3215c
jmp 0x3217b
leaq 0xf72e(%rip), %rdi      # 0x41891
leaq 0xe530(%rip), %rsi      # 0x4069a
movl $0x134, %edx            # imm = 0x134
leaq 0xf857(%rip), %rcx      # 0x419cd
callq 0x72e0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x11(%rbp)
je 0x3219a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x321a3
jmp 0x321a5
jmp 0x321c4
leaq 0xf83e(%rip), %rdi      # 0x419ea
leaq 0xe4e7(%rip), %rsi      # 0x4069a
movl $0x135, %edx            # imm = 0x135
leaq 0xf80e(%rip), %rcx      # 0x419cd
callq 0x72e0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %xmm0
movaps 0xde3c(%rip), %xmm3     # 0x40010
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0xde40(%rip), %xmm2     # 0x40020
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x8(%rax), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x1, 0x20(%rax)
jne 0x3223c
jmp 0x3225b
leaq 0xf64e(%rip), %rdi      # 0x41891
leaq 0xe450(%rip), %rsi      # 0x4069a
movl $0x13d, %edx            # imm = 0x13D
leaq 0xf7b9(%rip), %rcx      # 0x41a0f
callq 0x72e0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x11(%rbp)
je 0x3227a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x32283
jmp 0x32285
jmp 0x322a4
leaq 0xf7a0(%rip), %rdi      # 0x41a2c
leaq 0xe407(%rip), %rsi      # 0x4069a
movl $0x13e, %edx            # imm = 0x13E
leaq 0xf770(%rip), %rcx      # 0x41a0f
callq 0x72e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %xmm0
movaps 0xdd5c(%rip), %xmm3     # 0x40010
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0xdd60(%rip), %xmm2     # 0x40020
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x18(%rax), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x1, 0x20(%rax)
jne 0x3235c
jmp 0x3237b
leaq 0xf52e(%rip), %rdi      # 0x41891
leaq 0xe330(%rip), %rsi      # 0x4069a
movl $0x11f, %edx            # imm = 0x11F
leaq 0xf52c(%rip), %rcx      # 0x418a2
callq 0x72e0
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
callq 0x324a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x324b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x105d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x20(%rax)
jne 0x323dc
jmp 0x323fb
leaq 0xf512(%rip), %rdi      # 0x418f5
leaq 0xe2b0(%rip), %rsi      # 0x4069a
movl $0x129, %edx            # imm = 0x129
leaq 0xf510(%rip), %rcx      # 0x41906
callq 0x72e0
callq 0x324a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
subq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
callq 0x324b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
subq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
callq 0x105d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
subq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movl $0x1, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq $-0x1, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq -0x10(%rbp), %rsi
callq 0x384a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x324ea
jmp 0x32509
leaq 0xf3d1(%rip), %rdi      # 0x418c2
leaq 0xe1a2(%rip), %rsi      # 0x4069a
movl $0x111, %edx            # imm = 0x111
leaq 0xf3c7(%rip), %rcx      # 0x418cb
callq 0x72e0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
callq 0x32ad0
movsd %xmm0, -0x18(%rbp)
callq 0x32ae0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x329a8
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movaps 0xd6e9(%rip), %xmm1     # 0x40010
movq -0x40(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xd6e8(%rip), %xmm1     # 0x40020
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x32966
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x48(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x3297c
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x48(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0x32907
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x30(%rbp), %xmm1
movaps 0xd643(%rip), %xmm2     # 0x40010
movaps %xmm2, -0x90(%rbp)
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0xd640(%rip), %xmm2     # 0x40020
movaps %xmm2, -0x80(%rbp)
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x32af0
movaps -0x90(%rbp), %xmm5
movaps -0x80(%rbp), %xmm4
movq -0x58(%rbp), %rdi
movsd -0x70(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
movq %rax, %xmm3
punpckldq %xmm5, %xmm3    # xmm3 = xmm3[0],xmm5[0],xmm3[1],xmm5[1]
subpd %xmm4, %xmm3
movaps %xmm3, %xmm4
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
addsd %xmm4, %xmm3
movq -0x30(%rbp), %rsi
callq 0x32b30
movq -0x50(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x32c00
movl $0x10, %edi
callq 0x7210
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
leaq 0xede5(%rip), %rsi      # 0x419ad
callq 0x7680
jmp 0x32bcf
movq -0x78(%rbp), %rdi
movq 0x28406(%rip), %rsi     # 0x5afe0
movq 0x283e7(%rip), %rdx     # 0x5afc8
callq 0x7790
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x7350
jmp 0x32d4d
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x32d60
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x32d80
jmp 0x32c40
leaq -0x41(%rbp), %rdi
callq 0x21b00
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x20f80
movq -0x98(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x20e10
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x32e00
jmp 0x32c7c
leaq -0x40(%rbp), %rdi
callq 0x20760
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
shrq %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x32cbb
movq -0x70(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x20780
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
jmp 0x32cfa
movq -0x70(%rbp), %rsi
subq $0x1, %rsi
leaq -0x40(%rbp), %rdi
callq 0x20780
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x70(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x20780
movq %rax, %rcx
movq -0xa8(%rbp), %rax
addq (%rcx), %rax
shrq %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x20810
movq -0xb0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x21b00
jmp 0x32d4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x20810
movq -0x20(%rbp), %rdi
callq 0x77b0
nopw %cs:(%rax,%rax)
// File: travisdowns[P]avx-turbo/cpuid.cpp
// Function: cpuid(int, int)
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 %rbp
movq %rsp, %rbp
pushq %rbx
movl %edi, -0x24(%rbp)
movl %esi, -0x28(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
cpuid
movl %eax, -0x20(%rbp)
movl %ebx, -0x1c(%rbp)
movl %ecx, -0x18(%rbp)
movl %edx, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: travisdowns[P]avx-turbo/cpuid.cpp
// Function: gfm_inner()
family_model gfm_inner() {
    auto cpuid1 = cpuid(1);
    family_model ret;
    ret.family   = (cpuid1.eax >> 8) & 0xF;
    ret.model    = (cpuid1.eax >> 4) & 0xF;
    ret.stepping = (cpuid1.eax     ) & 0xF;
    if (ret.family == 15) {
        ret.family += (cpuid1.eax >> 20) & 0xFF;  // extended family
    }
    if (ret.family == 15 || ret.family == 6) {
        ret.model += ((cpuid1.eax >> 16) & 0xF) << 4; // extended model
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, %edi
callq 0x36530
movq %rax, -0x14(%rbp)
movq %rdx, -0xc(%rbp)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
andl $0xf, %eax
movb %al, -0x3(%rbp)
movl -0x14(%rbp), %eax
shrl $0x4, %eax
andl $0xf, %eax
movb %al, -0x2(%rbp)
movl -0x14(%rbp), %eax
andl $0xf, %eax
movb %al, -0x1(%rbp)
movzbl -0x3(%rbp), %eax
cmpl $0xf, %eax
jne 0x36669
movl -0x14(%rbp), %ecx
shrl $0x14, %ecx
andl $0xff, %ecx
movzbl -0x3(%rbp), %eax
addl %ecx, %eax
movb %al, -0x3(%rbp)
movzbl -0x3(%rbp), %eax
cmpl $0xf, %eax
je 0x3667b
movzbl -0x3(%rbp), %eax
cmpl $0x6, %eax
jne 0x36690
movl -0x14(%rbp), %ecx
shrl $0x10, %ecx
andl $0xf, %ecx
shll $0x4, %ecx
movzbl -0x2(%rbp), %eax
addl %ecx, %eax
movb %al, -0x2(%rbp)
movb -0x1(%rbp), %al
movb %al, -0x16(%rbp)
movw -0x3(%rbp), %ax
movw %ax, -0x18(%rbp)
movzbl -0x16(%rbp), %ecx
shll $0x10, %ecx
movzwl -0x18(%rbp), %eax
orl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x36560
cmpl $0xb, %eax
jae 0x36a4e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x36aee
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %esi
movl $0xb, %edi
callq 0x365d0
movq %rax, -0x1c(%rbp)
movq %rdx, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl $0x8, %esi
movl $0xf, %edx
callq 0x369f0
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %edi
xorl %esi, %esi
movl $0xf, %edx
callq 0x369f0
cmpl $0x0, %eax
je 0x36aa0
cmpl $0x0, -0x20(%rbp)
jne 0x36aa2
jmp 0x36ae8
cmpl $0x1, -0x20(%rbp)
jne 0x36ad8
cmpl $-0x1, -0x8(%rbp)
je 0x36ac6
movq 0x2451b(%rip), %rax     # 0x5afd0
movq (%rax), %rdi
leaq 0xb3f9(%rip), %rsi      # 0x41eb8
movb $0x0, %al
callq 0x7670
movl -0x1c(%rbp), %edi
xorl %esi, %esi
movl $0x4, %edx
callq 0x369f0
movl %eax, -0x8(%rbp)
jmp 0x36ada
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x36a5c
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0x36560
cmpl $0x15, %eax
jae 0x36c90
leaq 0xb27b(%rip), %rdi      # 0x41ef7
movb $0x0, %al
callq 0x7080
movq $0x0, -0x8(%rbp)
jmp 0x36dd3
movl $0x15, %edi
callq 0x36530
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x36160
movq -0x70(%rbp), %rdi
callq 0x71a0
movq %rax, %rsi
leaq 0xb27b(%rip), %rdi      # 0x41f41
xorl %eax, %eax
callq 0x7080
jmp 0x36ccf
leaq -0x38(%rbp), %rdi
callq 0x7290
cmpl $0x0, -0x10(%rbp)
je 0x36d13
movl -0x10(%rbp), %eax
movl -0x14(%rbp), %ecx
imulq %rcx, %rax
movl -0x18(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
jmp 0x36dd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7290
jmp 0x36de0
callq 0x366c0
movw %ax, %cx
movw %cx, -0x47(%rbp)
shrl $0x10, %eax
movb %al, -0x45(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x47(%rbp), %rsi
callq 0x37110
movq -0x78(%rbp), %rdi
callq 0x71a0
movq %rax, %rsi
leaq 0xb204(%rip), %rdi      # 0x41f4d
xorl %eax, %eax
callq 0x7080
jmp 0x36d52
leaq -0x68(%rbp), %rdi
callq 0x7290
movzbl -0x47(%rbp), %eax
cmpl $0x6, %eax
jne 0x36dbd
movzbl -0x46(%rbp), %eax
cmpl $0x4e, %eax
je 0x36d8c
movzbl -0x46(%rbp), %eax
cmpl $0x5e, %eax
je 0x36d8c
movzbl -0x46(%rbp), %eax
cmpl $0x8e, %eax
je 0x36d8c
movzbl -0x46(%rbp), %eax
cmpl $0x9e, %eax
jne 0x36dbb
movl -0x14(%rbp), %eax
imulq $0x16e3600, %rax, %rax  # imm = 0x16E3600
movl -0x18(%rbp), %ecx
cqto
idivq %rcx
movq %rax, -0x8(%rbp)
jmp 0x36dd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x7290
jmp 0x36de0
jmp 0x36dcb
leaq 0xb192(%rip), %rdi      # 0x41f56
movb $0x0, %al
callq 0x7080
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x77b0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
lfence
callq 0x36ef0
movq %rax, -0x8(%rbp)
callq 0x36f20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x2710, %rax           # imm = 0x2710
movq %rax, -0x28(%rbp)
callq 0x36ef0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jbe 0x36eae
jmp 0x36e8d
callq 0x36ef0
movq %rax, -0x18(%rbp)
callq 0x36f20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq -0x10(%rbp), %rax
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
movq -0x18(%rbp), %rcx
subq -0x8(%rbp), %rcx
xorl %edx, %edx
divq %rcx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x9b0, %rsp            # imm = 0x9B0
movq $0x0, -0x658(%rbp)
cmpq $0xca, -0x658(%rbp)
jae 0x36f90
callq 0x36e70
movq %rax, -0x998(%rbp)
movq -0x658(%rbp), %rsi
leaq -0x650(%rbp), %rdi
callq 0x373e0
movq -0x998(%rbp), %rcx
movq %rcx, (%rax)
movq -0x658(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x658(%rbp)
jmp 0x36f46
leaq -0x650(%rbp), %rdi
callq 0x37410
addq $0x328, %rax            # imm = 0x328
movq %rax, -0x9b0(%rbp)
leaq -0x650(%rbp), %rdi
callq 0x37430
movq %rax, -0x9a8(%rbp)
leaq -0x980(%rbp), %rdi
callq 0x32870
movq -0x9b0(%rbp), %rdi
movq -0x9a8(%rbp), %rsi
movq %rax, %rdx
callq 0x33080
leaq -0x980(%rbp), %rdi
callq 0x32870
movq %rax, -0x9a0(%rbp)
leaq -0x980(%rbp), %rdi
callq 0x32890
movq -0x9a0(%rbp), %rdi
movq %rax, %rsi
callq 0x37460
leaq -0x980(%rbp), %rdi
callq 0x32870
addq $0x140, %rax            # imm = 0x140
movq %rax, -0x988(%rbp)
movq -0x988(%rbp), %rdi
movq -0x988(%rbp), %rsi
addq $0xa0, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x374a0
movq %rax, -0x990(%rbp)
movq -0x990(%rbp), %rax
movl $0x14, %ecx
xorl %edx, %edx
divq %rcx
addq $0x9b0, %rsp            # imm = 0x9B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: travisdowns[P]avx-turbo/tsc-support.cpp
// Function: get_tsc_freq(bool)
uint64_t get_tsc_freq(bool force_calibrate) {
    uint64_t tsc;
    if (!force_calibrate && (tsc = get_tsc_from_cpuid())) {
        return tsc;
    }

    return tsc_from_cal();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x3709f
callq 0x36df0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3709f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x370a8
callq 0x36f30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: travisdowns[P]avx-turbo/tsc-support.cpp
// Function: get_tsc_cal_info(bool)
const char* get_tsc_cal_info(bool force_calibrate) {
    if (!force_calibrate && get_tsc_from_cpuid()) {
        return "from cpuid leaf 0x15";
    } else {
        return "from calibration loop";
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x370ee
callq 0x36df0
cmpq $0x0, %rax
je 0x370ee
leaq 0xaec4(%rip), %rax      # 0x41fac
movq %rax, -0x8(%rbp)
jmp 0x370f9
leaq 0xaecc(%rip), %rax      # 0x41fc1
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: travisdowns[P]avx-turbo/cpu.c
// Function: psnip_cpu_feature_check
int
psnip_cpu_feature_check (enum PSnipCPUFeature feature) {
#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64)
  unsigned int i, r, b;
#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64)
  unsigned long b, i;
#endif

#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64)
  if ((feature & PSNIP_CPU_FEATURE_CPU_MASK) != PSNIP_CPU_FEATURE_X86)
    return 0;
#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64)
  if ((feature & PSNIP_CPU_FEATURE_CPU_MASK) != PSNIP_CPU_FEATURE_ARM)
    return 0;
#else
  return 0;
#endif

  feature &= (enum PSnipCPUFeature) ~PSNIP_CPU_FEATURE_CPU_MASK;
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4152)
#endif
  psnip_once_call (&psnip_cpu_once, psnip_cpu_init);
#if defined(_MSC_VER)
#pragma warning(pop)
#endif

#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64)
  i = (feature >> 16) & 0xff;
  r = (feature >>  8) & 0xff;
  b = (feature      ) & 0xff;

  if (i > 7 || r > 3 || b > 31)
    return 0;

  return (psnip_cpuinfo[(i * 4) + r] >> b) & 1;
#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64)
  b = 1 << ((feature & 0xff) - 1);
  i = psnip_cpuinfo[(feature >> 0x08) & 0xff];
  return (psnip_cpuinfo[(feature >> 0x08) & 0xff] & b) == b;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x1f000000, %eax       # imm = 0x1F000000
cmpl $0x1000000, %eax        # imm = 0x1000000
je 0x38026
movl $0x0, -0x4(%rbp)
jmp 0x380a8
movl -0x8(%rbp), %eax
andl $0xe0ffffff, %eax       # imm = 0xE0FFFFFF
movl %eax, -0x8(%rbp)
leaq 0x24388(%rip), %rdi     # 0x5c3c0
leaq 0x81(%rip), %rsi        # 0x380c0
callq 0x77f0
movl -0x8(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x14(%rbp)
cmpl $0x7, -0xc(%rbp)
ja 0x3807d
cmpl $0x3, -0x10(%rbp)
ja 0x3807d
cmpl $0x1f, -0x14(%rbp)
jbe 0x38086
movl $0x0, -0x4(%rbp)
jmp 0x380a8
movl -0xc(%rbp), %eax
shll $0x2, %eax
addl -0x10(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x24336(%rip), %rax     # 0x5c3d0
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
shrl %cl, %eax
andl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: travisdowns[P]avx-turbo/cpu.c
// Function: psnip_cpu_init
static void psnip_cpu_init(void) {
#if defined(PSNIP_CPU_ARCH_X86) || defined(PSNIP_CPU_ARCH_X86_64)
  int i;
  for (i = 0 ; i < 8 ; i++) {
    psnip_cpu_getid(i, (int*) &(psnip_cpuinfo[i * 4]));
  }
#elif defined(PSNIP_CPU_ARCH_ARM) || defined(PSNIP_CPU_ARCH_ARM_64)
  psnip_cpuinfo[0] = getauxval (AT_HWCAP);
  psnip_cpuinfo[1] = getauxval (AT_HWCAP2);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x8, -0x4(%rbp)
jge 0x380fe
movl -0x4(%rbp), %edi
movl -0x4(%rbp), %eax
shll $0x2, %eax
cltq
leaq 0x242e9(%rip), %rsi     # 0x5c3d0
shlq $0x2, %rax
addq %rax, %rsi
callq 0x381d0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x380cf
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x3815c
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x38000
cmpl $0x0, %eax
jne 0x3814f
movl $0x0, -0x4(%rbp)
jmp 0x38163
jmp 0x38151
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x38123
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x38273
jmp 0x38292
leaq 0x9d7c(%rip), %rdi      # 0x41ff6
leaq 0x9d7e(%rip), %rsi      # 0x41fff
movl $0x36, %edx
leaq 0x9d7f(%rip), %rcx      # 0x4200c
callq 0x72e0
callq 0x38220
movl -0x4(%rbp), %eax
cmpl 0x231e0(%rip), %eax     # 0x5b480
jl 0x3832d
movl 0x231d4(%rip), %eax     # 0x5b480
shll %eax
cmpl -0x4(%rbp), %eax
jle 0x382c0
movl 0x231c7(%rip), %eax     # 0x5b480
shll %eax
movl %eax, -0x6c(%rbp)
jmp 0x382c6
movl -0x4(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
cltq
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x72f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x2319c(%rip), %rsi     # 0x5b488
movslq 0x2318d(%rip), %rdx     # 0x5b480
shlq $0x2, %rdx
callq 0x73c0
leaq 0x2418d(%rip), %rax     # 0x5c490
cmpq %rax, 0x2317e(%rip)     # 0x5b488
je 0x38318
movq 0x23175(%rip), %rdi     # 0x5b488
callq 0x7540
movq -0x18(%rbp), %rax
movq %rax, 0x23165(%rip)     # 0x5b488
movq -0x10(%rbp), %rax
movl %eax, 0x23153(%rip)     # 0x5b480
movq 0x23154(%rip), %rax     # 0x5b488
movslq -0x4(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x383dd
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x7230
leaq -0x60(%rbp), %rdi
movl -0x4(%rbp), %ecx
movl $0x40, %esi
leaq 0x9cba(%rip), %rdx      # 0x4201f
movb $0x0, %al
callq 0x7710
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
jle 0x38377
jmp 0x38396
leaq 0x9cb1(%rip), %rdi      # 0x4202f
leaq 0x9c7a(%rip), %rsi      # 0x41fff
movl $0x49, %edx
leaq 0x9c7b(%rip), %rcx      # 0x4200c
callq 0x72e0
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x7360
movl %eax, %edx
movq 0x230dc(%rip), %rax     # 0x5b488
movslq -0x4(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x230ce(%rip), %rax     # 0x5b488
movslq -0x4(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x383db
callq 0x7070
xorl %edx, %edx
subl (%rax), %edx
movq 0x230b4(%rip), %rax     # 0x5b488
movslq -0x4(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x383dd
movq 0x230a4(%rip), %rax     # 0x5b488
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x68(%rbp)
callq 0x38240
movl -0x68(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
callq 0x38260
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x38425
jmp 0x38444
leaq 0x9c0b(%rip), %rdi      # 0x42037
leaq 0x9bcc(%rip), %rsi      # 0x41fff
movl $0x59, %edx
leaq 0x9bfd(%rip), %rcx      # 0x4203c
callq 0x72e0
cmpl $0x0, -0x1c(%rbp)
jge 0x38452
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3848a
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, %ecx
movl $0x8, %edx
callq 0x7580
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x3847d
callq 0x7070
movl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x38484
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x38484
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
jne 0x384e7
jmp 0x38506
leaq 0x9b76(%rip), %rdi      # 0x42064
leaq 0x9b0a(%rip), %rsi      # 0x41fff
movl $0x6a, %edx
leaq 0x9b6d(%rip), %rcx      # 0x4206e
callq 0x72e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x76e0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x76e0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
leaq 0x9b52(%rip), %rdi      # 0x42085
movb $0x0, %al
callq 0x7080
movq $-0x1, -0x20(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
leaq -0x20(%rbp), %rdx
callq 0x38400
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3856d
movl -0x24(%rbp), %esi
leaq 0x9b3d(%rip), %rdi      # 0x420a1
movb $0x0, %al
callq 0x7080
jmp 0x3857f
movq -0x20(%rbp), %rsi
leaq 0x9b33(%rip), %rdi      # 0x420ab
movb $0x0, %al
callq 0x7080
movl -0x18(%rbp), %edi
leaq -0x20(%rbp), %rsi
callq 0x384a0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x385a7
movl -0x24(%rbp), %esi
leaq 0x9b03(%rip), %rdi      # 0x420a1
movb $0x0, %al
callq 0x7080
jmp 0x385b9
movq -0x20(%rbp), %rsi
leaq 0x9af9(%rip), %rdi      # 0x420ab
movb $0x0, %al
callq 0x7080
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x8, %rax
jb 0x38612
movq 0x229d8(%rip), %rax     # 0x5afd0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x9aad(%rip), %rsi      # 0x420b6
movb $0x0, %al
callq 0x7670
jmp 0x3863e
movq 0x229b7(%rip), %rax     # 0x5afd0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x22e64(%rip), %rax     # 0x5b490
movq (%rax,%rcx,8), %rcx
leaq 0x9adb(%rip), %rsi      # 0x42112
movb $0x0, %al
callq 0x7670
callq 0x7240
nopw %cs:(%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::preprocess_stdin_to_stdout()
auto preprocess_stdin_to_stdout() -> void
        {
            C->read_stdin = 1;
            C->eof = 0;
            C->bufsize = 80;
            C->len = 0;
            C->buf = C->malloced_buf = XX malloc(C->bufsize);
            C->out->output_char = [] (char x, void*) { putchar(x); };
            process_context();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x20(%rax), %rcx
movl $0x1, 0x1c(%rcx)
movq 0x20(%rax), %rcx
movl $0x0, 0x40(%rcx)
movq 0x20(%rax), %rcx
movl $0x50, 0x14(%rcx)
movq 0x20(%rax), %rcx
movl $0x0, 0x10(%rcx)
movq 0x20(%rax), %rax
movslq 0x14(%rax), %rdi
callq 0x21a0
movq %rax, %rsi
leaq -0x11(%rbp), %rdi
callq 0x3060
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3730
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdx
movq %rcx, 0x8(%rdx)
movq 0x20(%rax), %rax
movq %rcx, (%rax)
leaq -0x12(%rbp), %rdi
callq 0x3750
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq 0x20(%rdi), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x10(%rax)
callq 0x3770
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x2d66
jmp 0x2d3d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x2d59
movq -0x10(%rbp), %rdi
movl 0x10(%rdi), %esi
decl %esi
callq 0x7860
jmp 0x2d57
jmp 0x2d3d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2170
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2dc1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rdi
callq 0x2170
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xa8(%rax), %rdi
callq 0x2170
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xb0(%rax), %rdi
callq 0x2170
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x93c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2170
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2dfb
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2170
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x38(%rax), %rdi
callq 0x2170
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2170
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x2810
nopl (%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::preprocess_to_buffer(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>>&)
auto preprocess_to_buffer(std::string const& source, std::string& output) -> void
        {
            C->read_stdin = 0;
            C->eof = 0;
            C->buf = C->malloced_buf = XX malloc(source.size() + 2);    // prepend '\n', append '\0'

            auto first = &C->buf[1];
            auto last = std::copy_if(begin(source), end(source), first, [] (char x) { return (x != '\r'); });
            *last = '\0';
            C->buf[0] = '\n';
            C->len = XXX last - C->buf;
            C->bufsize = C->len + 1;

            C->out->output_char_data = &output;
            C->out->output_char = [] (char x, void* raw_output) {
                auto& output = *(std::string*)(raw_output);
                output += x;
            };
            process_context();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x20(%rax), %rcx
movl $0x0, 0x1c(%rcx)
movq 0x20(%rax), %rax
movl $0x0, 0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0x20e0
movq %rax, %rdi
addq $0x2, %rdi
callq 0x21a0
movq %rax, %rsi
leaq -0x21(%rbp), %rdi
callq 0x3060
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3730
movq %rax, %rdx
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rdx, 0x8(%rcx)
movq 0x20(%rax), %rcx
movq %rdx, (%rcx)
movq 0x20(%rax), %rax
movq (%rax), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaec0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaef0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdx
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xaa80
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movb $0x0, (%rcx)
movq 0x20(%rax), %rcx
movq (%rcx), %rcx
movb $0xa, (%rcx)
movq -0x38(%rbp), %rsi
movq 0x20(%rax), %rax
movq (%rax), %rax
subq %rax, %rsi
leaq -0x59(%rbp), %rdi
callq 0xab00
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xab30
movl %eax, %edx
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rcx
movl %edx, 0x10(%rcx)
movq 0x20(%rax), %rcx
movl 0x10(%rcx), %edx
addl $0x1, %edx
movq 0x20(%rax), %rcx
movl %edx, 0x14(%rcx)
movq -0x18(%rbp), %rcx
movq 0x20(%rax), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x18(%rax)
leaq -0x5a(%rbp), %rdi
callq 0xab50
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movq 0x20(%rdi), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x10(%rax)
callq 0x3770
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)