LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/ToolsBtsConv.cpp
// Function: Srl::Tools::bytes_to_hex(unsigned char const*, unsigned long)
vector<uint8_t> Tools::bytes_to_hex(const uint8_t* bytes, size_t nbytes)
{
    const char hex_lk[] {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
    };

    vector<uint8_t> hexv(nbytes * 2);

    for(size_t in_idx = 0, out_idx = 0; in_idx < nbytes;
               in_idx++, out_idx += 2) {

        hexv[out_idx]     = hex_lk[(bytes[in_idx] >> 4) & 0x0F];
        hexv[out_idx + 1] = hex_lk[bytes[in_idx] & 0x0F];
    }

    return hexv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq (%rdx,%rdx), %rsi
leaq 0xf(%rsp), %rdx
callq 0xbd40
testq %rbx, %rbx
je 0x1bd8b
xorl %eax, %eax
leaq 0x4210(%rip), %rcx      # 0x1ff70
movzbl (%r15,%rax), %edx
shrl $0x4, %edx
movb (%rdx,%rcx), %dl
movq (%r14), %rsi
movb %dl, (%rsi,%rax,2)
movzbl (%r15,%rax), %edx
andl $0xf, %edx
movb (%rdx,%rcx), %dl
movq (%r14), %rsi
movb %dl, 0x1(%rsi,%rax,2)
incq %rax
cmpq %rax, %rbx
jne 0x1bd60
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/ToolsStrConv.cpp
// Function: Srl::Tools::trim_space(unsigned char const*&, unsigned long&)
void Tools::trim_space(const uint8_t*& str, size_t& str_len)
{
    if(str == nullptr) {
        return;
    }

    while(str_len > 0 && is_space(*str)) {
        str++;
        str_len--;
    }

    while(str_len > 0 && is_space(*(str + str_len - 1))) {
        str_len--;
    }
}

// Assembly:
cmpq $0x0, (%rdi)
je 0x1c14a
movq (%rsi), %rax
testq %rax, %rax
je 0x1c120
movq (%rdi), %rcx
decq %rax
incq %rcx
movzbl -0x1(%rcx), %edx
leal -0x9(%rdx), %r8d
cmpl $0x5, %r8d
jae 0x1c11b
movq %rcx, (%rdi)
movq %rax, (%rsi)
incq %rcx
addq $-0x1, %rax
jb 0x1c0fc
jmp 0x1c120
cmpl $0x20, %edx
je 0x1c10a
movq (%rsi), %rax
testq %rax, %rax
je 0x1c14a
movq (%rdi), %rcx
decq %rax
movzbl (%rcx,%rax), %edx
leal -0x9(%rdx), %edi
cmpl $0x5, %edi
jae 0x1c145
movq %rax, (%rsi)
addq $-0x1, %rax
jb 0x1c12e
jmp 0x1c14a
cmpl $0x20, %edx
je 0x1c13a
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/ToolsStrConv.cpp
// Function: Srl::Tools::str_to_type(Srl::String const&, Srl::Type)
pair<bool, Value> Tools::str_to_type(const String& string_wrap, Type hint)
{
    if(string_wrap.encoding() == Encoding::UTF8) {
        return str_to_type(string_wrap.data(), string_wrap.size(), hint);

    } else {
        auto vec = Tools::conv_charset(Encoding::UTF8, string_wrap, false);
        if(vec.size() < 1) {
            return make_pair(false, Value(Type::Null));
        }

        return str_to_type(vec.data(), vec.size(), hint);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %rdx
movq %rdi, %rbx
cmpb $0x1, 0xd(%rsi)
jne 0x1c573
cmpb $0x0, 0xe(%rdx)
movq %rdx, %rsi
jne 0x1c562
movq (%rdx), %rsi
movl 0x8(%rdx), %edx
movzbl %bpl, %ecx
movq %rbx, %rdi
callq 0xb270
jmp 0x1c5d3
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0xbea0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
subq %rsi, %rdx
je 0x1c5a1
movzbl %bpl, %ecx
movq %rbx, %rdi
callq 0xb270
jmp 0x1c5bc
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movl $0x0, 0x18(%rbx)
xorl %eax, %eax
movb %al, (%rbx)
movw $0xb, 0x1c(%rbx)
movb %al, 0x1e(%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c5d3
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xb940
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c5f9
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xb940
movq %rbx, %rdi
callq 0xbe90
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/ToolsStrConv.cpp
// Function: Srl::Tools::conv_charset(Srl::Encoding, Srl::String const&, bool)
vector<uint8_t> Tools::conv_charset(Encoding target_encoding, const String& string_wrap, bool throw_error)
{
    vector<uint8_t> buffer;
    auto converted_total = conv_charset(target_encoding, string_wrap, buffer, throw_error);
    buffer.resize(converted_total);

    return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %esi, %edi
movq %rdx, %rsi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0xbc60
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb980
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1c653
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xb940
movq %r14, %rdi
callq 0xbe90
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/ToolsStrConv.cpp
// Function: std::enable_if<Srl::TpTools::is_num(Srl::Type)((Srl::Type)7) && !Srl::TpTools::is_fp(Srl::Type)((Srl::Type)7), unsigned long>::type (anonymous namespace)::conv_type<(Srl::Type)7>(Srl::Value const&, std::vector<unsigned char, std::allocator<unsigned char>>&)
typename enable_if<TpTools::is_num(TP) && !TpTools::is_fp(TP), size_t>::type
    conv_type(const Value& value, vector<uint8_t>& out)
    {
        typedef typename TpTools::Real<TP>::type T;
        const auto buffer_size = size_t(numeric_limits<T>::digits10) + 1 + TpTools::is_signed(TP);

        uint8_t buffer[buffer_size];

        bool negative = TpTools::is_signed(TP) && value.pblock().i64 < 0;

        uint64_t val = negative ? -value.pblock().i64 : value.pblock().ui64;

        if(val == 0) {
            if(out.size() < 1) out.resize(1);
            out[0] = '0';
            return 1;
        }

        size_t str_len = 0;
        auto* ptr = buffer + buffer_size - 1;

        for(; val > 0U;
            val /= 10U, ptr--, str_len++) {

            *ptr = '0' + val % 10;
        }

        if(negative) {
            *(ptr) = '-';
            str_len++;
        } else {
            ptr++;
        }

        Aux::copy_to_vec(out, ptr, str_len);

        return str_len;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x1cbe9
movq %rsi, %rcx
negq %rcx
cmovsq %rsi, %rcx
movq $-0x1, %rdi
leaq 0x13(%rsp), %r15
xorl %r14d, %r14d
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %r8
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r9d
subl %eax, %r9d
orb $0x30, %r9b
movb %r9b, 0x14(%rsp,%rdi)
incq %r14
decq %rdi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x1cbaa
testq %rsi, %rsi
js 0x1cc0d
movq %rsp, %r15
subq %r14, %r15
addq $0x14, %r15
jmp 0x1cc1b
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
jne 0x1cbff
movl $0x1, %esi
movq %rbx, %rdi
callq 0xb980
movq (%rbx), %rax
movb $0x30, (%rax)
movl $0x1, %r14d
jmp 0x1cc40
subq %r14, %r15
movb $0x2d, 0x14(%rsp,%rdi)
negq %rdi
movq %rdi, %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq %r14, %rax
jae 0x1cc32
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb980
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb790
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Tree.cpp
// Function: Srl::Tree::operator=(Srl::Tree&&)
Tree& Tree::operator= (Tree&& g)
{
    this->root_node = g.root_node;
    this->env       = move(g.env);
    if(this->env) {
        this->env->tree = this;
    }
    g.root_node = nullptr;

    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq (%rsi), %rsi
movq $0x0, (%r14)
callq 0xbda0
movq (%rbx), %rax
testq %rax, %rax
je 0x1d1fe
movq %rbx, (%rax)
movq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Tree.cpp
// Function: Srl::Tree::prologue_in(Srl::Parser&, Srl::Lib::In::Source&)
void Tree::prologue_in(Parser& parser, Lib::In::Source& source)
{
    if(this->env) {
        this->clear();

    } else {
        this->create_env();
    }

    this->env->set_input(parser, source);

    MemBlock name; Value val;
    tie(name, val) = parser.read(this->env->in);

    if(!TpTools::is_scope(val.type())) {
        throw Exception("Unable to parse source. Data malformed.");
    }

    auto* link = this->env->create_node(val.type(), name);
    this->root_node = &link->field;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x1d337
movq %rbx, %rdi
callq 0xba20
jmp 0x1d344
movq %rbx, %rdi
movl $0xe, %esi
callq 0xb890
movq (%rbx), %rdi
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rsi
callq 0xb3a0
movl $0x260, %edx            # imm = 0x260
addq (%rbx), %rdx
movq (%r14), %rax
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movb 0x24(%r15), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0xe, %cl
jne 0x1d3c1
leaq 0x20(%rsp), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rsi
movq (%rbx), %rdi
movq %rcx, (%rdx)
movl %esi, 0x8(%rdx)
movw $0x10c, 0xc(%rdx)       # imm = 0x10C
movb $0x0, 0xe(%rdx)
movzbl %al, %esi
callq 0xb1c0
addq $0x8, %rax
movq %rax, 0x8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0xb3b0
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2e31(%rip), %rsi      # 0x2020f
leaq 0x2e51(%rip), %rdx      # 0x20236
leaq 0x20(%rsp), %rdi
callq 0xb2e0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xb1d0
xorl %ebp, %ebp
movq 0xabe0(%rip), %rsi      # 0x27fe8
movq 0xab39(%rip), %rdx      # 0x27f48
movq %rbx, %rdi
callq 0xbe60
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d439
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb940
jmp 0x1d439
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1d446
movq %rbx, %rdi
callq 0xb610
movq %r14, %rdi
callq 0xbe90
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/Tree.cpp
// Function: Srl::Tree::to_source(Srl::Type, Srl::Parser&, Srl::Lib::Out::Source, std::function<void ()> const&)
void Tree::to_source(Type type, Parser& parser, Lib::Out::Source source, const function<void()>& store_switch)
{
    if(!this->env) {
        this->create_env();
    }
    this->env->set_output(parser, source);
    this->env->parsing = true;

    auto& name = this->root_node->name();
    this->env->write(Value(type), name);

    store_switch();

    this->env->write(Value(Type::Scope_End), name);

    this->env->parsing = false;
    this->env->out.flush();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movl %r8d, %r13d
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x1d4d6
movq %rbx, %rdi
movl $0xe, %esi
callq 0xb890
movq (%rbx), %rdi
movzbl %r13b, %ecx
movq %r12, %rsi
movq %r15, %rdx
callq 0xbd60
movq (%rbx), %rdi
movb $0x1, 0x258(%rdi)
movq 0x8(%rbx), %rax
movq 0x48(%rax), %r15
testq %r15, %r15
jne 0x1d506
movq 0xaa3a(%rip), %r15      # 0x27f40
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0x0, 0x10(%rsi)
movb %bpl, 0x14(%rsi)
movw $0x0, 0x15(%rsi)
movq %r15, %rdx
callq 0xb8d0
cmpq $0x0, 0x10(%r14)
je 0x1d582
movq %r14, %rdi
callq *0x18(%r14)
movq (%rbx), %rdi
movq %rsp, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movl $0x0, 0x10(%rsi)
movw $0x10, 0x14(%rsi)
xorl %ebp, %ebp
movb %bpl, 0x16(%rsi)
movq %r15, %rdx
callq 0xb8d0
movq (%rbx), %rdi
movb %bpl, 0x258(%rdi)
addq $0x2b0, %rdi            # imm = 0x2B0
callq 0xbde0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb2d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/night-shift[P]Srl/src/lib/fpconv/fpconv.c
// Function: multiply
static Fp multiply(Fp* a, Fp* b)
{
    const uint64_t lomask = 0x00000000FFFFFFFF;

    uint64_t ah_bl = (a->frac >> 32)    * (b->frac & lomask);
    uint64_t al_bh = (a->frac & lomask) * (b->frac >> 32);
    uint64_t al_bl = (a->frac & lomask) * (b->frac & lomask);
    uint64_t ah_bh = (a->frac >> 32)    * (b->frac >> 32);

    uint64_t tmp = (ah_bl & lomask) + (al_bh & lomask) + (al_bl >> 32);
    /* round up */
    tmp += 1U << 31;

    Fp fp = {
        ah_bh + (ah_bl >> 32) + (al_bh >> 32) + (tmp >> 32),
        a->exp + b->exp + 64
    };

    return fp;
}

// Assembly:
movq (%rdi), %rax
movl %eax, %r8d
movq %rax, %r9
shrq $0x20, %r9
movq (%rsi), %r10
movl %r10d, %eax
movq %rax, %rcx
imulq %r9, %rcx
shrq $0x20, %r10
movq %r10, %rdx
imulq %r8, %rdx
imulq %r8, %rax
imulq %r9, %r10
movl %ecx, %r8d
movl %edx, %r9d
addq %r8, %r9
shrq $0x20, %rax
addq %r9, %rax
subq $-0x80000000, %rax      # imm = 0x80000000
shrq $0x20, %rcx
addq %r10, %rcx
shrq $0x20, %rdx
addq %rcx, %rdx
shrq $0x20, %rax
addq %rdx, %rax
movl 0x8(%rdi), %ecx
movl 0x8(%rsi), %edx
addl %ecx, %edx
addl $0x40, %edx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_STTNI.cpp
// Function: buildPrefixList(unsigned int*, unsigned int)
PrefixList* buildPrefixList(uint32_t* a, uint32_t a_len) {
	PrefixNode* head = NULL;
	PrefixNode* last = NULL;
	for (int i = 0; i < a_len; i++) {
		uint16_t h16 = _high16(a[i]);
		if (head != NULL) {
			assert(last != NULL);
			if (h16 == last->prefix) {
				last->cnt++;
			} else {
				PrefixNode* last2 = new PrefixNode(NULL, i, 1, h16);
				last->next = last2;
				last = last2;
			}
		} else {
			head = new PrefixNode(NULL, i, 1, h16);
			last = head;
		}
	}

	PrefixList* pl = new PrefixList;
	pl->head = head;
	pl->data = a;
	pl->data_len = a_len;
	return pl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testl %esi, %esi
movl %esi, 0x4(%rsp)
je 0x24c9
movl %esi, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
xorl %r15d, %r15d
movzwl 0x2(%r14,%r13,4), %ebx
testq %rbp, %rbp
je 0x2473
testq %r15, %r15
je 0x24f2
cmpw %bx, 0xe(%r15)
jne 0x249a
incw 0xc(%r15)
jmp 0x24bf
movl $0x10, %edi
callq 0x2160
movq %rax, %r15
movq $0x0, (%rax)
movl %r13d, 0x8(%rax)
movw $0x1, 0xc(%rax)
movw %bx, 0xe(%rax)
movq %rax, %rbp
jmp 0x24bf
movl $0x10, %edi
callq 0x2160
movq $0x0, (%rax)
movl %r13d, 0x8(%rax)
movw $0x1, 0xc(%rax)
movw %bx, 0xe(%rax)
movq %rax, (%r15)
movq %rax, %r15
incq %r13
cmpq %r13, %r12
jne 0x2451
jmp 0x24cb
xorl %ebp, %ebp
movl $0x18, %edi
callq 0x2160
movq %rbp, (%rax)
movq %r14, 0x8(%rax)
movl 0x4(%rsp), %ecx
movl %ecx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b67(%rip), %rdi      # 0x6060
leaq 0x3b6d(%rip), %rsi      # 0x606d
leaq 0x3b75(%rip), %rcx      # 0x607c
movl $0x1b, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_STTNI.cpp
// Function: dumpPrefixList(PrefixList*)
void dumpPrefixList(PrefixList* pl) {
	PrefixNode* n = pl->head;
	while (n != NULL) {
		cout<<n->offset<<"\t"<<n->cnt<<"\t"<<hex<<n->prefix<<endl;
		n = n->next;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
testq %r12, %r12
je 0x25d0
movq 0x6aac(%rip), %rbx      # 0x8fd8
leaq 0x4335(%rip), %r14      # 0x6868
movl 0x8(%r12), %esi
movq %rbx, %rdi
callq 0x20c0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
movzwl 0xc(%r12), %esi
movq %r15, %rdi
callq 0x20c0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movzwl 0xe(%r12), %esi
movq %r15, %rdi
callq 0x20c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq (%r12), %r12
testq %r12, %r12
jne 0x2533
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_STTNI.cpp
// Function: dumpPrefixList2(PrefixList*)
void dumpPrefixList2(PrefixList* pl) {
	PrefixNode* n = pl->head;
        while (n != NULL) {
		for (int i = n->offset; i < n->offset+n->cnt; i++) {
			cout<<pl->data[i]<<endl;
		}
                n = n->next;
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x2660
movq %rdi, %rbx
movq 0x69e1(%rip), %r14      # 0x8fd8
movslq 0x8(%r12), %r13
movzwl 0xc(%r12), %eax
addl %r13d, %eax
cmpl %eax, %r13d
jae 0x2657
movq 0x8(%rbx), %rax
movl (%rax,%r13,4), %esi
movq %r14, %rdi
callq 0x20c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incq %r13
movzwl 0xc(%r12), %eax
addl 0x8(%r12), %eax
cmpl %r13d, %eax
ja 0x260a
movq (%r12), %r12
testq %r12, %r12
jne 0x25f7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_STTNI.cpp
// Function: intersect(unsigned int*, unsigned int, unsigned int*, unsigned int, unsigned int*, unsigned short)
uint32_t intersect(uint32_t * a, uint32_t a_len, uint32_t * b, uint32_t b_len, uint32_t* c, uint16_t high16) {
	uint32_t* c_begin = c;
	uint32_t ai = 0;
	uint32_t bi = 0;
	uint32_t a_st = (a_len/8) * 8;
	uint32_t b_st = (b_len/8) * 8;
	uint16_t a16[8];
	uint16_t b16[8];
	uint16_t c16[8];
	while (ai < a_st && bi < b_st) {
		a16[0] = _low16(a[ai+0]);
		a16[1] = _low16(a[ai+1]);
		a16[2] = _low16(a[ai+2]);
		a16[3] = _low16(a[ai+3]);
		a16[4] = _low16(a[ai+4]);
		a16[5] = _low16(a[ai+5]);
		a16[6] = _low16(a[ai+6]);
		a16[7] = _low16(a[ai+7]);

		b16[0] = _low16(b[bi+0]);
		b16[1] = _low16(b[bi+1]);
		b16[2] = _low16(b[bi+2]);
		b16[3] = _low16(b[bi+3]);
		b16[4] = _low16(b[bi+4]);
		b16[5] = _low16(b[bi+5]);
		b16[6] = _low16(b[bi+6]);
		b16[7] = _low16(b[bi+7]);

		uint32_t count = intersect_vector16(a16, b16, c16);

		for (uint32_t i = 0; i < count; i++) {
			uint32_t res = high16;
			res <<= 16;
			res |= c16[i];
			*c = res;
			c++;
		}

		uint16_t a_max = a16[7];
		uint16_t b_max = b16[7];
		ai += (a_max <= b_max) * 8;
		bi += (a_max >= b_max) * 8;
	}


	while (ai < a_len && bi < b_len) {
		if (a[ai] < b[bi]) {
			ai++;
		} else if (a[ai] > b[bi]) {
			bi++;
		} else {
			*c = a[ai];
			c++; ai++; bi++;
		}
	}
	return c - c_begin;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r10
movq %rdx, %r11
movl %esi, %ebp
andl $-0x8, %ebp
sete %al
movl %ecx, %r15d
andl $-0x8, %r15d
sete %dl
xorl %r14d, %r14d
orb %al, %dl
movl $0x0, %ebx
movq %r8, -0x20(%rsp)
jne 0x2782
movq 0x6aa8(%rip), %r8       # 0x9150
shll $0x10, %r9d
xorl %ebx, %ebx
movq -0x20(%rsp), %r10
xorl %r14d, %r14d
movl %ebx, %eax
vmovdqu (%rdi,%rax,4), %ymm0
vpmovdw %ymm0, %xmm1
movl %r14d, %eax
vmovdqu (%r11,%rax,4), %ymm0
vpmovdw %ymm0, %xmm2
movl $0x8, %eax
movl $0x8, %edx
vpcmpestrm $0x1, %xmm1, %xmm2
vmovd %xmm0, %eax
movslq %eax, %rdx
movq %rdx, %r13
shlq $0x4, %r13
vpshufb (%r8,%r13), %xmm1, %xmm0
vmovdqa %xmm0, -0x18(%rsp)
testl %edx, %edx
je 0x272b
popcntl %eax, %eax
cmpl $0x1, %eax
adcl $0x0, %eax
xorl %edx, %edx
xorl %r13d, %r13d
movzwl -0x18(%rsp,%r13,2), %r12d
orl %r9d, %r12d
movl %r12d, (%r10,%r13,4)
incq %r13
addq $-0x4, %rdx
cmpq %r13, %rax
jne 0x270f
subq %rdx, %r10
vpextrw $0x7, %xmm2, %eax
vpextrw $0x7, %xmm1, %edx
xorl %r13d, %r13d
xorl %r12d, %r12d
cmpw %ax, %dx
setae %r13b
setbe %r12b
leal (%rbx,%r12,8), %ebx
leal (%r14,%r13,8), %r14d
cmpl %ebp, %ebx
jae 0x2782
cmpl %r15d, %r14d
jb 0x26b6
jmp 0x2782
cmpl %ecx, %r14d
jae 0x2786
movl %ebx, %eax
movl (%rdi,%rax,4), %eax
movl %r14d, %edx
cmpl (%r11,%rdx,4), %eax
jae 0x2774
incl %ebx
jmp 0x2782
ja 0x277f
movl %eax, (%r10)
addq $0x4, %r10
incl %ebx
incl %r14d
cmpl %esi, %ebx
jb 0x275d
subq -0x20(%rsp), %r10
shrq $0x2, %r10
movl %r10d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_STTNI.cpp
// Function: intersectPrefixList(PrefixList*, PrefixList*, unsigned int*)
uint32_t intersectPrefixList(PrefixList* a, PrefixList* b, uint32_t* c) {
	uint32_t c_pos = 0;
	PrefixNode* an = a->head;
	PrefixNode* bn = b->head;

	while (an != NULL && bn != NULL) {
		if (an->prefix == bn->prefix) {
			c_pos += intersect(a->data + an->offset, an->cnt, b->data + bn->offset, bn->cnt, c + c_pos, an->prefix);
			an = an->next;
			bn = bn->next;
		} else if (an->prefix < bn->prefix) {
			an = an->next;
		} else {
			bn = bn->next;
		}
	}
	return c_pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
movq (%rsi), %r13
testq %r12, %r12
setne %al
testq %r13, %r13
setne %cl
andb %al, %cl
xorl %ebp, %ebp
cmpb $0x1, %cl
jne 0x2830
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movzwl 0xe(%r12), %eax
cmpw 0xe(%r13), %ax
jne 0x281a
movl 0x8(%r12), %edi
shlq $0x2, %rdi
addq 0x8(%r15), %rdi
movzwl 0xc(%r12), %esi
movl 0x8(%r13), %edx
shlq $0x2, %rdx
addq 0x8(%r14), %rdx
movzwl 0xc(%r13), %ecx
movl %ebp, %r8d
leaq (%rbx,%r8,4), %r8
movzwl %ax, %r9d
callq 0x266a
addl %eax, %ebp
movq (%r12), %r12
jmp 0x2822
jae 0x2822
movq (%r12), %r12
jmp 0x2826
movq (%r13), %r13
testq %r12, %r12
je 0x2830
testq %r13, %r13
jne 0x27d1
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_STTNI.cpp
// Function: prepare_shuffling_dict16()
void prepare_shuffling_dict16() {
	for (int i = 0; i  < 256; i++) {
		int counter = 0;
		char permutation[16];
		memset(permutation, 0xFF, sizeof(permutation));
		for (char b = 0; b < 8; b++) {
			if (getBit(i, b)) {
				permutation[counter++] = 2*b;
				permutation[counter++] = 2*b + 1;
			}
		}
		__m128i mask = _mm_loadu_si128((const __m128i*)permutation);
		shuffle_mask16[i] = mask;
	}
}

// Assembly:
movq 0x68f6(%rip), %rax      # 0x9150
xorl %ecx, %ecx
vpcmpeqd %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, -0x18(%rsp)
movb $0x1, %dl
xorl %esi, %esi
xorl %edi, %edi
btl %esi, %ecx
jae 0x2885
movslq %edi, %r8
leal -0x1(%rdx), %edi
movb %dil, -0x18(%rsp,%r8)
leal 0x2(%r8), %edi
movb %dl, -0x17(%rsp,%r8)
incl %esi
addb $0x2, %dl
cmpl $0x8, %esi
jne 0x286c
vmovaps -0x18(%rsp), %xmm1
movq %rcx, %rdx
shlq $0x4, %rdx
vmovaps %xmm1, (%rax,%rdx)
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x2860
retq
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_STTNI.cpp
// Function: main3()
int main3() {
	prepare_shuffling_dict16();

	uint16_t A[8] = {1, 3, 7, 19, 23, 31, 37, 41};
	uint16_t B[8] = {2, 4, 7, 19, 24, 31, 39, 40};
	uint16_t* C = new uint16_t[8];
	uint32_t count = intersect_vector16(A, B, C); 
	cout<<"count="<<count<<endl;
	for (int i = 0; i < count; i++) {
		cout<<C[i]<<endl;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x2853
movl $0x10, %edi
callq 0x2030
movq %rax, %rbx
vpmovsxbw 0x377e(%rip), %xmm1 # 0x6050
vpmovsxbw 0x377d(%rip), %xmm0 # 0x6058
movl $0x8, %eax
movl $0x8, %edx
vpcmpestrm $0x1, %xmm1, %xmm0
vmovd %xmm0, %eax
movq 0x685a(%rip), %rcx      # 0x9150
movslq %eax, %r12
movq %r12, %rax
shlq $0x4, %rax
vpshufb (%rcx,%rax), %xmm1, %xmm0
vmovdqu %xmm0, (%rbx)
popcntl %r12d, %r14d
movq 0x66c2(%rip), %r15      # 0x8fd8
leaq 0x3791(%rip), %rsi      # 0x60ae
movl $0x6, %edx
movq %r15, %rdi
callq 0x2180
movq %r15, %rdi
movq %r14, %rsi
callq 0x20c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
testl %r12d, %r12d
je 0x29b5
cmpl $0x1, %r14d
adcl $0x0, %r14d
xorl %r13d, %r13d
movq 0x6662(%rip), %r15      # 0x8fd8
movzwl (%rbx,%r13,2), %esi
movq %r15, %rdi
callq 0x20c0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incq %r13
cmpq %r13, %r14
jne 0x2976
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_STTNI.cpp
// Function: main2()
int main2() {
	uint32_t a[] = {
		0xFED01001,
		0xFED20001,
		0xFED20002,
		0xFED30001,
		0xFED30002,
		0xFED30003,
	};

	uint32_t a_len = sizeof(a)/sizeof(a[0]);


	PrefixList* a_pl = buildPrefixList(a, a_len);
	dumpPrefixList(a_pl);


	
	uint32_t b[] = {
		0xFED01001,
	//	0xFED20001,
	//	0xFED20002,
		0xFED30001,
	//	0xFED30002,
		0xFED30003,
	};

	uint32_t b_len = sizeof(b)/sizeof(b[0]);


	PrefixList* b_pl = buildPrefixList(b, b_len);
	dumpPrefixList(b_pl);


	uint32_t * c = new uint32_t[a_len];
	uint32_t c_cnt = intersectPrefixList(a_pl, b_pl, c);

	cout<<c_cnt<<endl;
	for (int i = 0; i < c_cnt; i++) {
		cout<<hex<<c[i]<<endl;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
vmovaps 0x3709(%rip), %xmm0     # 0x60e0
leaq 0x10(%rsp), %rdi
vmovaps %xmm0, (%rdi)
movabsq $-0x12cfffc012cfffe, %rax # imm = 0xFED30003FED30002
movq %rax, 0x10(%rdi)
movl $0x6, %esi
callq 0x242c
movq %rax, %r14
movq %rax, %rdi
callq 0x2511
movabsq $-0x12cfffe012fefff, %rax # imm = 0xFED30001FED01001
movq %rsp, %rdi
movq %rax, (%rdi)
movl $0xfed30003, 0x8(%rdi)  # imm = 0xFED30003
movl $0x3, %esi
callq 0x242c
movq %rax, %r15
movq %rax, %rdi
callq 0x2511
movl $0x18, %edi
callq 0x2030
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x27a0
movl %eax, %ebp
movl %eax, %r14d
movq 0x6582(%rip), %r15      # 0x8fd8
movq %r15, %rdi
movq %r14, %rsi
callq 0x20c0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
testl %ebp, %ebp
je 0x2ae7
xorl %r13d, %r13d
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movl (%rbx,%r13,4), %esi
movq %r15, %rdi
callq 0x20c0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incq %r13
cmpq %r13, %r14
jne 0x2a92
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_STTNI.cpp
// Function: main4(int, char**)
int main4(int argc, char* argv[]) {
        string file1 = argv[1];

        uint32_t a_len = 0;
        uint32_t* a = read_sorted_int_from_file(file1, &a_len);

        PrefixList* pl = buildPrefixList(a, a_len);

	dumpPrefixList2(pl);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x8(%rsi), %rsi
leaq 0x28(%rsp), %rbx
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2cf4
movl $0x0, (%r14)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2d32
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x5520
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2b65
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x242c
movq %rax, %rdi
callq 0x25dc
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b94
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2170
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2bbf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x2bbf
jmp 0x2bbc
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bda
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_STTNI.cpp
// Function: main5()
int main5() {
        prepare_shuffling_dict16();

        uint32_t _A[8] = {16449536, 16449580, 16449914, 16450040, 16450068, 16450264, 16450296, 16450304};
	uint16_t A[8] = {0};
	for (int i = 0; i < 8; i++) {
		A[i] = _low16(_A[i]);
	}

	uint32_t _B[8] = {16449622, 16449724, 16449807, 16449856, 16449861, 16450264, 16450500, 16450581};
        uint16_t B[8] = {0};
	for (int i = 0; i < 8; i++) {
		B[i] = _low16(_B[i]);
	}

        uint16_t* C = new uint16_t[8];
        uint32_t count = intersect_vector16(A, B, C);
        cout<<"count="<<count<<endl;
        for (int i = 0; i < count; i++) {
                cout<<C[i]<<endl;
        }
        return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x2853
movl $0x10, %edi
callq 0x2030
movq %rax, %rbx
vmovdqa 0x342b(%rip), %xmm1     # 0x6030
vmovdqa 0x3433(%rip), %xmm0     # 0x6040
movl $0x8, %eax
movl $0x8, %edx
vpcmpestrm $0x1, %xmm1, %xmm0
vmovd %xmm0, %eax
movq 0x6528(%rip), %rcx      # 0x9150
movslq %eax, %r12
movq %r12, %rax
shlq $0x4, %rax
vpshufb (%rcx,%rax), %xmm1, %xmm0
vmovdqu %xmm0, (%rbx)
popcntl %r12d, %r14d
movq 0x6390(%rip), %r15      # 0x8fd8
leaq 0x345f(%rip), %rsi      # 0x60ae
movl $0x6, %edx
movq %r15, %rdi
callq 0x2180
movq %r15, %rdi
movq %r14, %rsi
callq 0x20c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
testl %r12d, %r12d
je 0x2ce7
cmpl $0x1, %r14d
adcl $0x0, %r14d
xorl %r13d, %r13d
movq 0x6330(%rip), %r15      # 0x8fd8
movzwl (%rbx,%r13,2), %esi
movq %r15, %rdi
callq 0x20c0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incq %r13
cmpq %r13, %r14
jne 0x2ca8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_bisearch.cpp
// Function: bisearch_intersection(unsigned int const*, unsigned int, unsigned int const*, unsigned int, unsigned int*)
uint32_t bisearch_intersection(const uint32_t* a, uint32_t a_len, const uint32_t* b, uint32_t b_len, uint32_t* c) {
	uint32_t c_pos = 0;
	for (int i = 0; i < b_len; i++) {
		if (bisearch(a, a_len, b[i]) >= 0) {
			c[c_pos++] = b[i];
		}
	}

	return c_pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
testl %ecx, %ecx
je 0x2ea4
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl %ecx, %r13d
xorl %ebx, %ebx
xorl %r12d, %r12d
movl (%r14,%rbx,4), %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x57e6
testl %eax, %eax
js 0x2e9a
movl (%r14,%rbx,4), %eax
movl %r12d, %ecx
incl %r12d
movq (%rsp), %rdx
movl %eax, (%rdx,%rcx,4)
incq %rbx
cmpq %rbx, %r13
jne 0x2e77
jmp 0x2ea7
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_block_merge.cpp
// Function: block_merge_intersection(unsigned int const*, unsigned int, unsigned int const*, unsigned int, unsigned int*)
uint32_t block_merge_intersection(const uint32_t* a, uint32_t a_len, const uint32_t* b, uint32_t b_len, uint32_t* c) {
	uint32_t c_pos = 0;
	uint32_t a_pos = 0;
	uint32_t b_pos = 0;

	while (a_pos+1<a_len && b_pos+1<b_len) {
		int a_data_0 = a[a_pos]; int a_data_1 = a[a_pos+1];
		int b_data_0 = b[b_pos]; int b_data_1 = b[b_pos+1];
		if (a_data_0 == b_data_0) {
			c[c_pos++] = a_data_0;
		}
	        else if (a_data_0 == b_data_1) {	
			c[c_pos++] = a_data_0;
			goto advanceB;
		} 
		else if (a_data_1 == b_data_0) {
			c[c_pos++] = a_data_1;
			goto advanceA;
		}
		if (a_data_1 == b_data_1) {
			c[c_pos++] = a_data_1;
			goto advanceAB;
		}
		else if (a_data_1 > b_data_1) goto advanceB;
		else goto advanceA;
advanceA:
		a_pos += 2;
		if (a_pos >= a_len){break;} else {continue;}
advanceB:
		b_pos += 2;
		if (b_pos >= b_len){break;} else {continue;}
advanceAB:
		a_pos += 2; b_pos += 2;
		if (a_pos >= a_len || b_pos >= b_len){break;}
	}
	
	while (a_pos < a_len && b_pos < b_len) {
		int a_data = a[a_pos];
		int b_data = b[b_pos];
		if (a_data == b_data) {
			c[c_pos++] = a_data;
			a_pos++;
			b_pos++;
		} else if (a_data > b_data) {
			b_pos++;
		} else {
			a_pos++;
		}
	}
	return c_pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
xorl %r9d, %r9d
xorl %r10d, %r10d
xorl %eax, %eax
leal 0x1(%r10), %r11d
cmpl %esi, %r11d
jae 0x2f7d
leal 0x1(%r9), %ebp
cmpl %ecx, %ebp
jae 0x2f7d
movl %r10d, %ebx
movl (%rdi,%rbx,4), %ebx
movl %r11d, %r11d
movl (%rdi,%r11,4), %r11d
movl %r9d, %r14d
movl (%rdx,%r14,4), %r14d
movl %ebp, %r15d
movl (%rdx,%r15,4), %ebp
cmpl %r14d, %ebx
jne 0x2f3b
movl %eax, %r14d
incl %eax
movl %ebx, (%r8,%r14,4)
cmpl %ebp, %r11d
jne 0x2f4a
movl %eax, %ebx
incl %eax
movl %r11d, (%r8,%rbx,4)
addl $0x2, %r10d
addl $0x2, %r9d
cmpl %esi, %r10d
setae %r11b
cmpl %ecx, %r9d
setae %bl
orb %r11b, %bl
movzbl %bl, %r11d
leal (%r11,%r11,2), %r11d
jmp 0x2f73
cmpl %ebp, %ebx
jne 0x2f55
movl %eax, %r11d
incl %eax
movl %ebx, (%r8,%r11,4)
jmp 0x2f4c
jle 0x2f62
addl $0x2, %r9d
cmpl %ecx, %r9d
jmp 0x2f69
cmpl %r14d, %r11d
jne 0x2f0c
movl %eax, %ebx
incl %eax
movl %r11d, (%r8,%rbx,4)
addl $0x2, %r10d
cmpl %esi, %r10d
movl $0x3, %r11d
sbbl $0x0, %r11d
cmpl $0x3, %r11d
jne 0x2eca
cmpl %esi, %r10d
setb %r11b
cmpl %ecx, %r9d
setb %bl
andb %r11b, %bl
cmpb $0x1, %bl
jne 0x2fc3
movl %r10d, %r11d
movl (%rdi,%r11,4), %r11d
movl %r9d, %ebx
cmpl (%rdx,%rbx,4), %r11d
jne 0x2faf
movl %eax, %ebx
incl %eax
movl %r11d, (%r8,%rbx,4)
incl %r10d
jmp 0x2fb1
jle 0x2fb6
incl %r9d
jmp 0x2fb9
incl %r10d
cmpl %esi, %r10d
jae 0x2fc3
cmpl %ecx, %r9d
jb 0x2f92
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_bloomfilter.cpp
// Function: bloomfilter_intersection(bloom_filter*, unsigned int const*, unsigned int, unsigned int const*, unsigned int, unsigned int*)
uint32_t bloomfilter_intersection(bloom_filter* filter, const uint32_t* a, uint32_t a_len, const uint32_t* b, uint32_t b_len, uint32_t* c) {
	uint32_t c_pos = 0;
	for (int i = 0; i < b_len; i++) {
		int b_data = b[i];
		if (filter->contains(b_data)) {
			if (bisearch(a, a_len, b_data) >= 0) {
				c[c_pos++] = b_data;
			}
		}
	}
	return c_pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq %rsi, 0x10(%rsp)
testl %r8d, %r8d
je 0x304c
movq %rcx, %r14
movq %rdi, %r12
movl %r8d, %ebp
xorl %r15d, %r15d
movq %rsp, %rbx
xorl %r13d, %r13d
movl (%r14,%r15,4), %eax
movl %eax, (%rsp)
movq (%r12), %rax
movl $0x4, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
testb %al, %al
je 0x3042
movl (%rsp), %edx
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x57e6
testl %eax, %eax
js 0x3042
movl (%rsp), %eax
movl %r13d, %ecx
incl %r13d
movq 0x8(%rsp), %rdx
movl %eax, (%rdx,%rcx,4)
incq %r15
cmpq %r15, %rbp
jne 0x2fff
jmp 0x304f
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_bloomfilter.cpp
// Function: create_bloom_filter(unsigned int const*, unsigned int)
bloom_filter* create_bloom_filter(const uint32_t* a, uint32_t a_len) {
	bloom_parameters parameters;
	
	parameters.projected_element_count = a_len;
	
	parameters.false_positive_probability = 0.0001;
	
	parameters.random_seed = 0xA5A5A5A5;

	parameters.compute_optimal_parameters();

	bloom_filter* filter = new bloom_filter(parameters);


	for (int i = 0; i < a_len; i++) {
		filter->insert(a[i]);
	}

	return filter;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x5ccf(%rip), %rax      # 0x8d48
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq $0x1, 0x8(%r15)
movq $-0x1, 0x10(%r15)
movl $0x1, 0x18(%r15)
movl $0xffffffff, 0x1c(%r15) # imm = 0xFFFFFFFF
movabsq $0x3f1a36e2eb1c432d, %rax # imm = 0x3F1A36E2EB1C432D
movq %rax, 0x28(%r15)
movl $0x0, 0x38(%r15)
movq $0x0, 0x40(%r15)
movl %esi, %r12d
movq %r12, 0x20(%r15)
movl $0xa5a5a5a5, %eax       # imm = 0xA5A5A5A5
movq %rax, 0x30(%r15)
movq %r15, %rdi
callq 0x313e
movl $0x68, %edi
callq 0x2160
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x3306
testl %ebp, %ebp
je 0x3115
movq %rsp, %r15
movq $0x4, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3b30
addq $0x4, %rbx
decq %r12
jne 0x30f6
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/./bloom_filter.hpp
// Function: bloom_filter::bloom_filter(bloom_parameters const&)
bloom_filter(const bloom_parameters& p)
   : projected_element_count_(p.projected_element_count),
     inserted_element_count_(0),
     random_seed_((p.random_seed * 0xA5A5A5A5) + 1),
     desired_false_positive_probability_(p.false_positive_probability)
   {
      salt_count_ = p.optimal_parameters.number_of_hashes;
      table_size_ = p.optimal_parameters.table_size;

      generate_unique_salt();

      bit_table_.resize(table_size_ / bits_per_char, static_cast<unsigned char>(0x00));
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5a68(%rip), %rax      # 0x8d80
movq %rax, (%rdi)
leaq 0x20(%rdi), %r14
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x8(%rdi)
vmovups %ymm0, 0x18(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x48(%rdi)
movq $0x0, 0x50(%rdi)
movl $0xa5a5a5a5, %eax       # imm = 0xA5A5A5A5
imulq 0x30(%rsi), %rax
incq %rax
movq %rax, 0x58(%rdi)
vmovsd 0x28(%rsi), %xmm0
vmovsd %xmm0, 0x60(%rdi)
movl 0x38(%rsi), %eax
movl %eax, 0x38(%rdi)
movq 0x40(%rsi), %rax
movq %rax, 0x40(%rdi)
vzeroupper
callq 0x33d8
movq 0x40(%rbx), %rsi
shrq $0x3, %rsi
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
movq %r14, %rdi
callq 0x3508
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3394
movq %rax, %r15
leaq 0x8(%rbx), %r12
movq (%r14), %rdi
testq %rdi, %rdi
je 0x33af
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x2170
movq (%r12), %rdi
testq %rdi, %rdi
je 0x33c4
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x2170
movq %r15, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/./bloom_filter.hpp
// Function: bloom_filter::contains(unsigned char const*, unsigned long) const
inline virtual bool contains(const unsigned char* key_begin, const std::size_t length) const
   {
      std::size_t bit_index = 0;
      std::size_t bit       = 0;

      for (std::size_t i = 0; i < salt_.size(); ++i)
      {
         compute_indices(hash_ap(key_begin, length, salt_[i]), bit_index, bit);

         if ((bit_table_[bit_index / bits_per_char] & bit_mask[bit]) != bit_mask[bit])
         {
            return false;
         }
      }

      return true;
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
sete %bpl
je 0x370e
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movl (%rax,%r13,4), %eax
cmpq $0x8, %rbx
jb 0x3611
movq %rbx, %rdx
movq %r14, %rcx
movl %eax, %esi
shrl $0x3, %esi
imull (%rcx), %esi
movl %eax, %edi
shrl $0x5, %edi
xorl 0x4(%rcx), %edi
addq $0x8, %rcx
movl %eax, %r8d
shll $0x7, %r8d
movl %eax, %r9d
shll $0xb, %r9d
addl %r9d, %edi
xorl %r8d, %edi
xorl %esi, %edi
xorl %edi, %eax
notl %eax
addq $-0x8, %rdx
cmpq $0x7, %rdx
ja 0x35d7
jmp 0x3617
movq %r14, %rcx
movq %rbx, %rdx
testq %rdx, %rdx
je 0x36b2
xorl %esi, %esi
cmpq $0x4, %rdx
jae 0x362d
movq %rdx, %rdi
jmp 0x3655
movl %eax, %esi
shll $0xb, %esi
movl %eax, %r8d
shrl $0x5, %r8d
xorl (%rcx), %r8d
addl %esi, %r8d
xorl %eax, %r8d
notl %r8d
leaq -0x4(%rdx), %rdi
addq $0x4, %rcx
movl $0x1, %esi
movl %r8d, %eax
cmpq $0x2, %rdi
jb 0x369c
movzwl (%rcx), %r8d
cmpq $0x4, %rdx
jae 0x3682
movl %eax, %edx
shll $0xb, %edx
movl %eax, %r9d
shrl $0x5, %r9d
xorl %r8d, %r9d
addl %edx, %r9d
xorl %eax, %r9d
notl %r9d
movl %r9d, %eax
jmp 0x3692
movl %eax, %edx
shll $0x7, %edx
xorl %eax, %edx
shrl $0x3, %eax
imull %r8d, %eax
xorl %edx, %eax
incl %esi
addq $-0x2, %rdi
addq $0x2, %rcx
testq %rdi, %rdi
je 0x36b2
movzbl (%rcx), %ecx
imull $0xa5a5a5a5, %eax, %edx # imm = 0xA5A5A5A5
xorl %ecx, %edx
addl %eax, %esi
addl %edx, %esi
movl %esi, %eax
movl %eax, 0x4(%rsp)
movq (%r15), %rax
movq %r15, %rdi
leaq 0x4(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r12, %rcx
callq *0x20(%rax)
movq 0x10(%rsp), %rax
shrq $0x3, %rax
movq 0x20(%r15), %rcx
movb (%rcx,%rax), %al
movq 0x8(%rsp), %rcx
notb %al
leaq 0x2a36(%rip), %rdx      # 0x6120
testb %al, (%rcx,%rdx)
jne 0x370e
incq %r13
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r13
setae %bpl
jb 0x35c7
andb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/./bloom_filter.hpp
// Function: bloom_filter::insert(unsigned char const*, unsigned long const&)
inline void insert(const unsigned char* key_begin, const std::size_t& length)
   {
      std::size_t bit_index = 0;
      std::size_t bit       = 0;

      for (std::size_t i = 0; i < salt_.size(); ++i)
      {
         compute_indices(hash_ap(key_begin, length, salt_[i]), bit_index, bit);

         bit_table_[bit_index / bits_per_char] |= bit_mask[bit];
      }

      ++inserted_element_count_;
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
je 0x3ca3
movq %rdx, %rbx
movq %rsi, %r15
xorl %r12d, %r12d
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq (%rbx), %rdx
movl (%rax,%r12,4), %eax
movq %r15, %rcx
cmpq $0x8, %rdx
jb 0x3bb6
movl %eax, %esi
shrl $0x3, %esi
imull (%rcx), %esi
movl %eax, %edi
shrl $0x5, %edi
xorl 0x4(%rcx), %edi
addq $0x8, %rcx
movl %eax, %r8d
shll $0x7, %r8d
movl %eax, %r9d
shll $0xb, %r9d
addl %r9d, %edi
xorl %r8d, %edi
xorl %esi, %edi
xorl %edi, %eax
notl %eax
addq $-0x8, %rdx
cmpq $0x7, %rdx
ja 0x3b7e
testq %rdx, %rdx
je 0x3c51
xorl %esi, %esi
cmpq $0x4, %rdx
jae 0x3bcc
movq %rdx, %rdi
jmp 0x3bf4
movl %eax, %esi
shll $0xb, %esi
movl %eax, %r8d
shrl $0x5, %r8d
xorl (%rcx), %r8d
addl %esi, %r8d
xorl %eax, %r8d
notl %r8d
leaq -0x4(%rdx), %rdi
addq $0x4, %rcx
movl $0x1, %esi
movl %r8d, %eax
cmpq $0x2, %rdi
jb 0x3c3b
movzwl (%rcx), %r8d
cmpq $0x4, %rdx
jae 0x3c21
movl %eax, %edx
shll $0xb, %edx
movl %eax, %r9d
shrl $0x5, %r9d
xorl %r8d, %r9d
addl %edx, %r9d
xorl %eax, %r9d
notl %r9d
movl %r9d, %eax
jmp 0x3c31
movl %eax, %edx
shll $0x7, %edx
xorl %eax, %edx
shrl $0x3, %eax
imull %r8d, %eax
xorl %edx, %eax
incl %esi
addq $-0x2, %rdi
addq $0x2, %rcx
testq %rdi, %rdi
je 0x3c51
movzbl (%rcx), %ecx
imull $0xa5a5a5a5, %eax, %edx # imm = 0xA5A5A5A5
xorl %ecx, %edx
addl %eax, %esi
addl %edx, %esi
movl %esi, %eax
movl %eax, 0x4(%rsp)
movq (%r14), %rax
movq %r14, %rdi
leaq 0x4(%rsp), %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq *0x20(%rax)
movq 0x8(%rsp), %rax
leaq 0x24ab(%rip), %rcx      # 0x6120
movb (%rax,%rcx), %al
movq 0x10(%rsp), %rcx
shrq $0x3, %rcx
movq 0x20(%r14), %rdx
orb %al, (%rdx,%rcx)
incq %r12
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jb 0x3b6e
incq 0x50(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_highlyscalable_avx2.cpp
// Function: prepare_shuffling_dict32()
void prepare_shuffling_dict32() {
        for (int i = 0; i  < 256; i++) {
                int counter = 0;
                char permutation[32];
                memset(permutation, 0xFF, sizeof(permutation));
                for (char b = 0; b < 8; b++) {
                        if (getBit(i, b)) {
                                //permutation[counter++] = 4*b;
                                //permutation[counter++] = 4*b + 1;
                                //permutation[counter++] = 4*b + 2;
                                //permutation[counter++] = 4*b + 3;
				
				permutation[counter++] = b & 0xff;
                                permutation[counter++] = (b >> 8) & 0xff;
                                permutation[counter++] = (b >> 16) & 0xff;
                                permutation[counter++] = (b >> 24) & 0xff;

                        }
                }
                __m256i mask = _mm256_loadu_si256((const __m256i*)permutation);
                shuffle_mask32[i] = mask;
        }
}

// Assembly:
xorl %eax, %eax
vpcmpeqd %ymm0, %ymm0, %ymm0
leaq 0x51b7(%rip), %rcx      # 0x9180
vmovdqu %ymm0, -0x28(%rsp)
xorl %edx, %edx
xorl %esi, %esi
btl %edx, %eax
jae 0x3ff8
movslq %esi, %rdi
movb %dl, -0x28(%rsp,%rdi)
movl %edx, %r8d
sarb $0x7, %r8b
movb %r8b, -0x27(%rsp,%rdi)
movb %r8b, -0x26(%rsp,%rdi)
leal 0x4(%rdi), %esi
movb %r8b, -0x25(%rsp,%rdi)
incl %edx
cmpl $0x8, %edx
jne 0x3fd3
vmovups -0x28(%rsp), %ymm1
movq %rax, %rdx
shlq $0x5, %rdx
vmovaps %ymm1, (%rdx,%rcx)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x3fc9
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_highlyscalable_avx2.cpp
// Function: main1()
int main1() {
        prepare_shuffling_dict32();

        uint32_t A[8] = {1, 3, 7, 19, 23, 31, 37, 41};
        uint32_t B[8] = {2, 4, 7, 19, 24, 31, 39, 40};
        uint32_t* C = new uint32_t[8];
        
	uint32_t count = highlyscalable_avx2_intersection(A, 8, B, 8, C);
	cout<<"count="<<count<<endl;
        for (int i = 0; i < count; i++) {
                cout<<C[i]<<endl;
        }
        return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
callq 0x3fbc
vmovups 0x24b7(%rip), %ymm0     # 0x6640
leaq 0x20(%rsp), %r14
vmovups %ymm0, (%r14)
vmovups 0x24c5(%rip), %ymm0     # 0x6660
movq %rsp, %r15
vmovups %ymm0, (%r15)
movl $0x20, %edi
vzeroupper
callq 0x2030
movq %rax, %rbx
movl $0x8, %esi
movl $0x8, %ecx
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %r8
callq 0x4020
movq %rax, %r14
movq 0x4e03(%rip), %r15      # 0x8fd8
leaq 0x1ed2(%rip), %rsi      # 0x60ae
movl $0x6, %edx
movq %r15, %rdi
callq 0x2180
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq %r14, %rsi
andq %r12, %rsi
movq %r15, %rdi
callq 0x20c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
andq %r14, %r12
je 0x4277
movl %r14d, %r12d
xorl %r13d, %r13d
movq 0x4d9f(%rip), %r14      # 0x8fd8
movl (%rbx,%r13,4), %esi
movq %r14, %rdi
callq 0x20c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incq %r13
cmpq %r13, %r12
jne 0x4239
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_highlyscalable_avx512.cpp
// Function: prepare_shuffling_dict64()
void prepare_shuffling_dict64() {
        for (int i = 0; i  < 65536; i++) {
                int counter = 0;
                char permutation[64];
                memset(permutation, 0xFF, sizeof(permutation));
                for (char b = 0; b < 16; b++) {
                        if (getBit(i, b)) {
				permutation[counter++] = b & 0xff;
                                permutation[counter++] = (b >> 8) & 0xff;
                                permutation[counter++] = (b >> 16) & 0xff;
                                permutation[counter++] = (b >> 24) & 0xff;

                        }
                }
                __m512i mask = _mm512_loadu_si512(permutation);
                shuffle_mask64[i] = mask;
        }
}

// Assembly:
xorl %eax, %eax
vpternlogd $0xff, %zmm0, %zmm0, %zmm0
leaq 0x6f28(%rip), %rcx      # 0xb1c0
vmovdqu64 %zmm0, -0x48(%rsp)
xorl %edx, %edx
xorl %esi, %esi
btl %edx, %eax
jae 0x42cc
movslq %esi, %rdi
movb %dl, -0x48(%rsp,%rdi)
movl %edx, %r8d
sarb $0x7, %r8b
movb %r8b, -0x47(%rsp,%rdi)
movb %r8b, -0x46(%rsp,%rdi)
leal 0x4(%rdi), %esi
movb %r8b, -0x45(%rsp,%rdi)
incl %edx
cmpl $0x10, %edx
jne 0x42a7
vmovups -0x48(%rsp), %zmm1
movq %rax, %rdx
shlq $0x6, %rdx
vmovaps %zmm1, (%rdx,%rcx)
incq %rax
cmpq $0x10000, %rax          # imm = 0x10000
jne 0x4298
vzeroupper
retq