LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x69e4(%rip), %r14      # 0x8fd8
movq %rdi, %rbx
movslq 0x8(%r12), %r13
movzwl 0xc(%r12), %eax
addl %r13d, %eax
cmpl %eax, %r13d
jae 0x2657
movq 0x8(%rbx), %rax
movq %r14, %rdi
movl (%rax,%r13,4), %esi
callq 0x20c0
movq %rax, %r15
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r15, %rdi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movzwl 0xc(%r12), %eax
incq %r13
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_O3/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
movl %esi, %ebp
andl $-0x8, %ebp
movl %ecx, %r15d
movq %rdx, %r11
movl $0x0, %ebx
movq %r8, %r10
movq %r8, -0x20(%rsp)
sete %al
andl $-0x8, %r15d
sete %dl
xorl %r14d, %r14d
orb %al, %dl
jne 0x277c
movq 0x6aa8(%rip), %r8       # 0x9150
movq -0x20(%rsp), %r10
shll $0x10, %r9d
xorl %ebx, %ebx
xorl %r14d, %r14d
movl %ebx, %eax
vmovdqu (%rdi,%rax,4), %ymm0
movl %r14d, %eax
movl $0x8, %edx
vpmovdw %ymm0, %xmm1
vmovdqu (%r11,%rax,4), %ymm0
movl $0x8, %eax
vpmovdw %ymm0, %xmm2
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 0x2725
popcntl %eax, %eax
xorl %edx, %edx
xorl %r13d, %r13d
movzwl -0x18(%rsp,%r13,2), %r12d
addq $-0x4, %rdx
orl %r9d, %r12d
movl %r12d, (%r10,%r13,4)
incq %r13
cmpq %r13, %rax
jne 0x2709
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 0x277c
cmpl %r15d, %r14d
jb 0x26b6
jmp 0x277c
cmpl %ecx, %r14d
jae 0x2780
movl %ebx, %eax
movl (%rdi,%rax,4), %eax
movl %r14d, %edx
cmpl (%r11,%rdx,4), %eax
jae 0x276e
incl %ebx
jmp 0x277c
ja 0x2779
movl %eax, (%r10)
addq $0x4, %r10
incl %ebx
incl %r14d
cmpl %esi, %ebx
jb 0x2757
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_O3/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
xorl %ebp, %ebp
andb %al, %cl
cmpb $0x1, %cl
jne 0x282a
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movzwl 0xe(%r12), %eax
cmpw 0xe(%r13), %ax
jne 0x2814
movl 0x8(%r12), %edi
movl 0x8(%r13), %edx
movzwl 0xc(%r12), %esi
movzwl 0xc(%r13), %ecx
movl %ebp, %r8d
leaq (%rbx,%r8,4), %r8
movzwl %ax, %r9d
shlq $0x2, %rdi
shlq $0x2, %rdx
addq 0x8(%r15), %rdi
addq 0x8(%r14), %rdx
callq 0x266a
movq (%r12), %r12
addl %eax, %ebp
jmp 0x281c
jae 0x281c
movq (%r12), %r12
jmp 0x2820
movq (%r13), %r13
testq %r12, %r12
je 0x282a
testq %r13, %r13
jne 0x27cb
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_O3/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 0x68fc(%rip), %rax      # 0x9150
vpcmpeqd %xmm0, %xmm0, %xmm0
xorl %ecx, %ecx
movb $0x1, %dl
vmovdqa %xmm0, -0x18(%rsp)
xorl %esi, %esi
xorl %edi, %edi
btl %esi, %ecx
jae 0x287f
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 0x2866
vmovaps -0x18(%rsp), %xmm1
movq %rcx, %rdx
shlq $0x4, %rdx
incq %rcx
vmovaps %xmm1, (%rax,%rdx)
cmpq $0x100, %rcx            # imm = 0x100
jne 0x285a
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x284d
movl $0x10, %edi
callq 0x2030
vpmovsxbw 0x3787(%rip), %xmm1 # 0x6050
vpmovsxbw 0x3786(%rip), %xmm0 # 0x6058
movq %rax, %rbx
movl $0x8, %eax
movl $0x8, %edx
movq 0x686a(%rip), %rcx      # 0x9150
movq 0x66eb(%rip), %r15      # 0x8fd8
leaq 0x37ba(%rip), %rsi      # 0x60ae
movq %r15, %rdi
vpcmpestrm $0x1, %xmm1, %xmm0
movl $0x6, %edx
vmovd %xmm0, %eax
movslq %eax, %r12
movq %r12, %rax
shlq $0x4, %rax
popcntl %r12d, %r14d
vpshufb (%rcx,%rax), %xmm1, %xmm0
vmovdqu %xmm0, (%rbx)
callq 0x2180
movq %r15, %rdi
movq %r14, %rsi
callq 0x20c0
movq %rax, %r15
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r15, %rdi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
testl %r12d, %r12d
je 0x29af
movq 0x6673(%rip), %r15      # 0x8fd8
cmpl $0x1, %r14d
adcl $0x0, %r14d
xorl %r13d, %r13d
movzwl (%rbx,%r13,2), %esi
movq %r15, %rdi
callq 0x20c0
movq %rax, %r12
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r12, %rdi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incq %r13
cmpq %r13, %r14
jne 0x2970
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x370f(%rip), %xmm0     # 0x60e0
leaq 0x10(%rsp), %rdi
movabsq $-0x12cfffc012cfffe, %rax # imm = 0xFED30003FED30002
movl $0x6, %esi
movq %rax, 0x10(%rdi)
vmovaps %xmm0, (%rdi)
callq 0x242c
movq %rax, %rdi
movq %rax, %r14
callq 0x2511
movabsq $-0x12cfffe012fefff, %rax # imm = 0xFED30001FED01001
movl $0x3, %esi
movq %rsp, %rdi
movl $0xfed30003, 0x8(%rdi)  # imm = 0xFED30003
movq %rax, (%rdi)
callq 0x242c
movq %rax, %rdi
movq %rax, %r15
callq 0x2511
movl $0x18, %edi
callq 0x2030
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x279a
movq 0x658d(%rip), %r15      # 0x8fd8
movl %eax, %r14d
movl %eax, %ebp
movq %r14, %rsi
movq %r15, %rdi
callq 0x20c0
movq %rax, %r12
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r12, %rdi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
testl %ebp, %ebp
je 0x2ae1
xorl %r13d, %r13d
movq (%r15), %rax
movl (%rbx,%r13,4), %esi
movq %r15, %rdi
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
callq 0x20c0
movq %rax, %r12
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r12, %rdi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incq %r13
cmpq %r13, %r14
jne 0x2a8c
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_O3/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 0x2cee
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movl $0x0, (%r14)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2d2c
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x5500
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %r14, %rdi
je 0x2b5f
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 0x2b8e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2170
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %r14, %rdi
je 0x2bb9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x2bb9
jmp 0x2bb6
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bd4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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 0x284d
movl $0x10, %edi
callq 0x2030
vmovdqa 0x3434(%rip), %xmm1     # 0x6030
vmovdqa 0x343c(%rip), %xmm0     # 0x6040
movq %rax, %rbx
movl $0x8, %eax
movl $0x8, %edx
movq 0x6538(%rip), %rcx      # 0x9150
movq 0x63b9(%rip), %r15      # 0x8fd8
leaq 0x3488(%rip), %rsi      # 0x60ae
movq %r15, %rdi
vpcmpestrm $0x1, %xmm1, %xmm0
movl $0x6, %edx
vmovd %xmm0, %eax
movslq %eax, %r12
movq %r12, %rax
shlq $0x4, %rax
popcntl %r12d, %r14d
vpshufb (%rcx,%rax), %xmm1, %xmm0
vmovdqu %xmm0, (%rbx)
callq 0x2180
movq %r15, %rdi
movq %r14, %rsi
callq 0x20c0
movq %rax, %r15
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r15, %rdi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
testl %r12d, %r12d
je 0x2ce1
movq 0x6341(%rip), %r15      # 0x8fd8
cmpl $0x1, %r14d
adcl $0x0, %r14d
xorl %r13d, %r13d
movzwl (%rbx,%r13,2), %esi
movq %r15, %rdi
callq 0x20c0
movq %rax, %r12
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r12, %rdi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incq %r13
cmpq %r13, %r14
jne 0x2ca2
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ea8
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 0x57ce
testl %eax, %eax
js 0x2e9e
movl (%r14,%rbx,4), %eax
movq (%rsp), %rdx
movl %r12d, %ecx
incl %r12d
movl %eax, (%rdx,%rcx,4)
incq %rbx
cmpq %rbx, %r13
jne 0x2e7b
jmp 0x2eab
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_O3/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 %r14
pushq %rbx
cmpl $0x2, %esi
setb %al
cmpl $0x2, %ecx
setb %r10b
xorl %r9d, %r9d
orb %al, %r10b
movl $0x0, %r10d
movl $0x0, %eax
jne 0x2fb4
movl $0x1, %ebx
movl $0x1, %r11d
xorl %eax, %eax
xorl %r10d, %r10d
xorl %r9d, %r9d
movl %r11d, %r11d
movl %ebx, %ebx
movl %r10d, %r14d
movl (%rdi,%r14,4), %ebp
movl %r9d, %r14d
movl (%rdi,%r11,4), %r11d
movl (%rdx,%r14,4), %r14d
movl (%rdx,%rbx,4), %ebx
cmpl %r14d, %ebp
jne 0x2f3f
movl %eax, %r14d
incl %eax
movl %ebp, (%r8,%r14,4)
cmpl %ebx, %r11d
jne 0x2f4e
movl %eax, %ebx
incl %eax
addl $0x2, %r10d
addl $0x2, %r9d
movl %r11d, (%r8,%rbx,4)
cmpl %esi, %r10d
jb 0x2f54
jmp 0x2fb4
cmpl %ebx, %ebp
jne 0x2f5b
movl %eax, %r11d
incl %eax
movl %ebp, (%r8,%r11,4)
jmp 0x2f50
jle 0x2f68
addl $0x2, %r9d
cmpl %ecx, %r9d
jb 0x2f71
jmp 0x2fb4
cmpl %r14d, %r11d
jne 0x2f23
movl %eax, %ebx
incl %eax
movl %r11d, (%r8,%rbx,4)
addl $0x2, %r10d
cmpl %esi, %r10d
jae 0x2fb4
leal 0x1(%r10), %r11d
cmpl %esi, %r11d
jae 0x2fb4
leal 0x1(%r9), %ebx
cmpl %ecx, %ebx
jb 0x2efb
jmp 0x2fb4
cmpl %ecx, %r9d
jae 0x2fb9
movl %r10d, %r11d
movl (%rdi,%r11,4), %r11d
movl %r9d, %ebx
cmpl (%rdx,%rbx,4), %r11d
jne 0x2faa
movl %eax, %ebx
incl %eax
movl %r11d, (%r8,%rbx,4)
incl %r10d
jmp 0x2fac
jle 0x2fb1
incl %r9d
jmp 0x2fb4
incl %r10d
cmpl %esi, %r10d
jb 0x2f88
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3040
movq %rcx, %r14
movq %rdi, %r12
movl %r8d, %ebp
xorl %r15d, %r15d
movq %rsp, %rbx
xorl %r13d, %r13d
movl (%r14,%r15,4), %eax
movl $0x4, %edx
movq %r12, %rdi
movq %rbx, %rsi
movl %eax, (%rsp)
movq (%r12), %rax
callq *0x10(%rax)
testb %al, %al
je 0x3036
movl (%rsp), %edx
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x57ce
testl %eax, %eax
js 0x3036
movl (%rsp), %eax
movq 0x8(%rsp), %rdx
movl %r13d, %ecx
incl %r13d
movl %eax, (%rdx,%rcx,4)
incq %r15
cmpq %r15, %rbp
jne 0x2ff3
jmp 0x3043
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_O3/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
leaq 0x5ce0(%rip), %rax      # 0x8d48
leaq 0x8(%rsp), %r15
movabsq $0x3f1a36e2eb1c432d, %rcx # imm = 0x3F1A36E2EB1C432D
movq %rdi, %rbx
movl %esi, %ebp
movl %esi, %r12d
movq %rax, (%r15)
movl $0xa5a5a5a5, %eax       # imm = 0xA5A5A5A5
movq $0x1, 0x8(%r15)
movq $-0x1, 0x10(%r15)
movl $0x1, 0x18(%r15)
movl $0xffffffff, 0x1c(%r15) # imm = 0xFFFFFFFF
movl $0x0, 0x38(%r15)
movq $0x0, 0x40(%r15)
movq %r12, 0x20(%r15)
movq %rcx, 0x28(%r15)
movq %r15, %rdi
movq %rax, 0x30(%r15)
callq 0x3132
movl $0x68, %edi
callq 0x2160
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x32e0
testl %ebp, %ebp
je 0x3109
movq %rsp, %r15
movq $0x4, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3b36
addq $0x4, %rbx
decq %r12
jne 0x30ea
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x68, %esi
movq %r14, %rdi
movq %rax, %rbx
callq 0x2170
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O3/ralgond[P]SortedListIntersection/./bloom_filter.hpp
// Function: bloom_parameters::compute_optimal_parameters()
inline bool operator!()
   {
      return (minimum_size > maximum_size)      ||
             (minimum_number_of_hashes > maximum_number_of_hashes) ||
             (minimum_number_of_hashes < 1)     ||
             (0 == maximum_number_of_hashes)    ||
             (0 == projected_element_count)     ||
             (false_positive_probability < 0.0) ||
             (std::numeric_limits<double>::infinity() == std::abs(false_positive_probability)) ||
             (0 == random_seed)                 ||
             (0xFFFFFFFFFFFFFFFFULL == random_seed);
   }

// Assembly:
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
jbe 0x313f
xorl %eax, %eax
retq
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movl 0x18(%rdi), %ecx
movq %rdi, %rbx
xorl %eax, %eax
decl %ecx
cmpl 0x1c(%rdi), %ecx
jae 0x31c7
cmpq $0x0, 0x20(%rbx)
je 0x31c7
movq 0x28(%rbx), %rax
movabsq $0xfffffffffffff, %rsi  # imm = 0xFFFFFFFFFFFFF
movq %rax, %rcx
btrq $0x3f, %rcx
leaq -0x1(%rcx), %rdx
cmpq %rsi, %rdx
movabsq $0x7ff0000000000000, %rsi # imm = 0x7FF0000000000000
setb %dl
testq %rax, %rax
sets %al
andb %al, %dl
cmpq %rsi, %rcx
sete %sil
orb %dl, %sil
movabsq $-0x10000000000000, %rdx # imm = 0xFFF0000000000000
addq %rcx, %rdx
shrq $0x35, %rdx
cmpl $0x3ff, %edx            # imm = 0x3FF
setb %cl
andb %al, %cl
orb %sil, %cl
jne 0x31c5
movq 0x30(%rbx), %rax
incq %rax
cmpq $0x2, %rax
jae 0x31ce
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
vmovsd 0x2f32(%rip), %xmm0     # 0x6108
vmovsd 0x2f32(%rip), %xmm1     # 0x6110
vxorpd %xmm2, %xmm2, %xmm2
movl $0x3e7, %ebp            # imm = 0x3E7
vmovapd %xmm0, (%rsp)
vmovsd %xmm1, 0x18(%rsp)
vmovapd %xmm2, 0x20(%rsp)
vmovapd (%rsp), %xmm0
vxorpd 0x2f11(%rip){1to2}, %xmm0, %xmm0 # 0x6118
vcvtusi2sdq 0x20(%rbx), %xmm4, %xmm1
vmulsd %xmm1, %xmm0, %xmm0
vmovsd 0x2eee(%rip), %xmm1     # 0x6108
vdivsd (%rsp), %xmm1, %xmm1
vmovsd %xmm0, 0x10(%rsp)
vmovsd 0x28(%rbx), %xmm0
callq 0x21f0
vmovsd 0x2ed1(%rip), %xmm1     # 0x6108
vsubsd %xmm0, %xmm1, %xmm0
callq 0x2100
vmovsd 0x10(%rsp), %xmm3
vmovsd 0x18(%rsp), %xmm1
vmovapd 0x20(%rsp), %xmm2
decl %ebp
vdivsd %xmm0, %xmm3, %xmm0
vmovapd (%rsp), %xmm3
vcmpltsd %xmm1, %xmm0, %k1
vminsd %xmm1, %xmm0, %xmm1
vmovsd %xmm3, %xmm2, %xmm2 {%k1}
vmovapd (%rsp), %xmm0
vaddsd 0x2e8d(%rip), %xmm0, %xmm0 # 0x6108
jne 0x31e7
vcvttsd2usi %xmm1, %rdx
movl $0x8, %ecx
vcvttsd2usi %xmm2, %eax
movl %edx, %esi
andl $0x7, %esi
movl %eax, 0x38(%rbx)
subq %rsi, %rcx
testq %rsi, %rsi
cmoveq %rsi, %rcx
addq %rdx, %rcx
movq %rcx, 0x40(%rbx)
movl 0x18(%rbx), %edx
cmpl %eax, %edx
ja 0x32b9
movl 0x1c(%rbx), %edx
cmpl %eax, %edx
jae 0x32bc
movl %edx, 0x38(%rbx)
movq 0x8(%rbx), %rdx
cmpq %rdx, %rcx
jb 0x32d4
movq 0x10(%rbx), %rdx
movb $0x1, %al
cmpq %rdx, %rcx
jbe 0x31c7
movb $0x1, %al
movq %rdx, 0x40(%rbx)
jmp 0x31c7
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x5a91(%rip), %rax      # 0x8d80
vxorps %xmm0, %xmm0, %xmm0
leaq 0x20(%rdi), %r14
movq %rdi, %rbx
movq %rax, (%rdi)
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 0x33b2
movq 0x40(%rbx), %rsi
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
shrq $0x3, %rsi
movq %r14, %rdi
callq 0x34e8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x336e
movq (%r14), %rdi
leaq 0x8(%rbx), %r12
movq %rax, %r15
testq %rdi, %rdi
je 0x3389
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x2170
movq (%r12), %rdi
testq %rdi, %rdi
je 0x339e
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x2170
movq %r15, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
cmpq %rcx, 0x10(%rdi)
je 0x36e9
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
movl (%rcx,%r12,4), %eax
cmpq $0x8, %rbx
jb 0x35f2
movq %rbx, %rdx
movq %r14, %rcx
movl %eax, %esi
shrl $0x3, %esi
movl %eax, %edi
shrl $0x5, %edi
imull (%rcx), %esi
xorl 0x4(%rcx), %edi
movl %eax, %r9d
shll $0xb, %r9d
movl %eax, %r8d
shll $0x7, %r8d
addq $0x8, %rcx
addq $-0x8, %rdx
addl %r9d, %edi
xorl %r8d, %edi
xorl %esi, %edi
xorl %edi, %eax
notl %eax
cmpq $0x7, %rdx
ja 0x35b8
jmp 0x35f8
movq %r14, %rcx
movq %rbx, %rdx
testq %rdx, %rdx
je 0x368e
cmpq $0x3, %rdx
ja 0x3634
xorl %esi, %esi
cmpq $0x1, %rdx
je 0x367d
movzwl (%rcx), %edi
movl %eax, %r8d
shrl $0x5, %r8d
movl %eax, %esi
shll $0xb, %esi
xorl %edi, %r8d
addl %esi, %r8d
movl $0x1, %esi
xorl %eax, %r8d
notl %r8d
movl %r8d, %eax
jmp 0x3670
movl %eax, %edi
shrl $0x5, %edi
xorl (%rcx), %edi
movl %eax, %esi
shll $0xb, %esi
addq $-0x4, %rdx
addq $0x4, %rcx
addl %esi, %edi
movl $0x1, %esi
xorl %edi, %eax
notl %eax
cmpq $0x2, %rdx
jb 0x3678
movzwl (%rcx), %edi
movl %eax, %esi
shll $0x7, %esi
xorl %eax, %esi
shrl $0x3, %eax
imull %edi, %eax
xorl %esi, %eax
movl $0x2, %esi
addq $-0x2, %rdx
addq $0x2, %rcx
testq %rdx, %rdx
je 0x368e
movzbl (%rcx), %ecx
imull $0xa5a5a5a5, %eax, %edx # imm = 0xA5A5A5A5
addl %eax, %esi
xorl %ecx, %edx
addl %edx, %esi
movl %esi, %eax
movl %eax, 0x4(%rsp)
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
movq %r13, %rdx
movq %rbp, %rcx
movq (%r15), %rax
callq *0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%r15), %rcx
leaq 0x2a6a(%rip), %rdx      # 0x6120
shrq $0x3, %rax
movb (%rcx,%rax), %al
movq 0x8(%rsp), %rcx
notb %al
testb %al, (%rcx,%rdx)
sete %al
jne 0x36eb
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rdx
incq %r12
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rdx, %r12
jb 0x35a8
jmp 0x36eb
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
je 0x3ca4
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %rdx, %rbx
movq %rsi, %r15
xorl %r12d, %r12d
movq (%rbx), %rcx
movl (%rax,%r12,4), %eax
movq %r15, %rdx
cmpq $0x8, %rcx
jb 0x3bbc
movl %eax, %esi
shrl $0x3, %esi
movl %eax, %edi
shrl $0x5, %edi
imull (%rdx), %esi
xorl 0x4(%rdx), %edi
movl %eax, %r9d
shll $0xb, %r9d
movl %eax, %r8d
shll $0x7, %r8d
addq $0x8, %rdx
addq $-0x8, %rcx
addl %r9d, %edi
xorl %r8d, %edi
xorl %esi, %edi
xorl %edi, %eax
notl %eax
cmpq $0x7, %rcx
ja 0x3b84
testq %rcx, %rcx
je 0x3c52
cmpq $0x3, %rcx
ja 0x3bf8
xorl %esi, %esi
cmpq $0x1, %rcx
je 0x3c41
movzwl (%rdx), %edi
movl %eax, %r8d
shrl $0x5, %r8d
movl %eax, %esi
shll $0xb, %esi
xorl %edi, %r8d
addl %esi, %r8d
movl $0x1, %esi
xorl %eax, %r8d
notl %r8d
movl %r8d, %eax
jmp 0x3c34
movl %eax, %edi
shrl $0x5, %edi
xorl (%rdx), %edi
movl %eax, %esi
shll $0xb, %esi
addq $-0x4, %rcx
addq $0x4, %rdx
addl %esi, %edi
movl $0x1, %esi
xorl %edi, %eax
notl %eax
cmpq $0x2, %rcx
jb 0x3c3c
movzwl (%rdx), %edi
movl %eax, %esi
shll $0x7, %esi
xorl %eax, %esi
shrl $0x3, %eax
imull %edi, %eax
xorl %esi, %eax
movl $0x2, %esi
addq $-0x2, %rcx
addq $0x2, %rdx
testq %rcx, %rcx
je 0x3c52
movzbl (%rdx), %ecx
imull $0xa5a5a5a5, %eax, %edx # imm = 0xA5A5A5A5
addl %eax, %esi
xorl %ecx, %edx
addl %edx, %esi
movl %esi, %eax
movl %eax, 0x4(%rsp)
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %rbp, %rcx
movq (%r14), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rax
leaq 0x24aa(%rip), %rcx      # 0x6120
movq 0x20(%r14), %rdx
incq %r12
movb (%rax,%rcx), %al
movq 0x10(%rsp), %rcx
shrq $0x3, %rcx
orb %al, (%rdx,%rcx)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jb 0x3b74
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_O3/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:
vpcmpeqd %ymm0, %ymm0, %ymm0
leaq 0x51ed(%rip), %rcx      # 0x9180
xorl %eax, %eax
vmovdqu %ymm0, -0x28(%rsp)
xorl %edx, %edx
xorl %esi, %esi
btl %edx, %eax
jae 0x3fba
movslq %esi, %rdi
leal 0x4(%rdi), %esi
movb %dl, -0x28(%rsp,%rdi)
movw $0x0, -0x27(%rsp,%rdi)
movb $0x0, -0x25(%rsp,%rdi)
incl %edx
cmpl $0x8, %edx
jne 0x3f9f
vmovups -0x28(%rsp), %ymm1
movq %rax, %rdx
shlq $0x5, %rdx
incq %rax
vmovaps %ymm1, (%rdx,%rcx)
cmpq $0x100, %rax            # imm = 0x100
jne 0x3f95
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f88
vmovups 0x24dd(%rip), %ymm0     # 0x6660
vmovups 0x24f5(%rip), %ymm1     # 0x6680
leaq 0x20(%rsp), %r14
movl $0x20, %edi
movq %rsp, %r15
vmovups %ymm0, (%r14)
vmovups %ymm1, (%r15)
vzeroupper
callq 0x2030
movl $0x8, %esi
movl $0x8, %ecx
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %r8
callq 0x3fe2
movq 0x4e0c(%rip), %r15      # 0x8fd8
leaq 0x1edb(%rip), %rsi      # 0x60ae
movl $0x6, %edx
movq %rax, %r14
movq %r15, %rdi
callq 0x2180
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq %r14, %rsi
movq %r15, %rdi
andq %r12, %rsi
callq 0x20c0
movq %rax, %r15
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r15, %rdi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
andq %r14, %r12
je 0x4271
movl %r14d, %r12d
movq 0x4da8(%rip), %r14      # 0x8fd8
xorl %r13d, %r13d
movl (%rbx,%r13,4), %esi
movq %r14, %rdi
callq 0x20c0
movq %rax, %r15
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %r15, %rdi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incq %r13
cmpq %r13, %r12
jne 0x4233
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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:
vpternlogd $0xff, %zmm0, %zmm0, %zmm0
leaq 0x6f2e(%rip), %rcx      # 0xb1c0
xorl %eax, %eax
vmovdqu64 %zmm0, -0x48(%rsp)
xorl %edx, %edx
xorl %esi, %esi
btl %edx, %eax
jae 0x42be
movslq %esi, %rdi
leal 0x4(%rdi), %esi
movb %dl, -0x48(%rsp,%rdi)
movw $0x0, -0x47(%rsp,%rdi)
movb $0x0, -0x45(%rsp,%rdi)
incl %edx
cmpl $0x10, %edx
jne 0x42a3
vmovups -0x48(%rsp), %zmm1
movq %rax, %rdx
shlq $0x6, %rdx
incq %rax
vmovaps %zmm1, (%rdx,%rcx)
cmpq $0x10000, %rax          # imm = 0x10000
jne 0x4294
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/ralgond[P]SortedListIntersection/algo_scalar.cpp
// Function: scalar(unsigned int const*, unsigned long, unsigned int const*, unsigned long, unsigned int*)
size_t scalar(const uint32_t *A, const size_t lenA, const uint32_t *B,
              const size_t lenB, uint32_t *out) {
  const uint32_t *const initout(out);
  if (lenA == 0 || lenB == 0)
    return 0;

  const uint32_t *endA = A + lenA;
  const uint32_t *endB = B + lenB;

  while (1) {
    while (*A < *B) {
    SKIP_FIRST_COMPARE:
      if (++A == endA)
        return (out - initout);
    }
    while (*A > *B) {
      if (++B == endB)
        return (out - initout);
    }
    if (*A == *B) {
      *out++ = *A;
      if (++A == endA || ++B == endB)
        return (out - initout);
    } else {
      goto SKIP_FIRST_COMPARE;
    }
  }

  return (out - initout); // NOTREACHED
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rcx, %rcx
sete %r9b
orb %al, %r9b
je 0x4499
xorl %eax, %eax
retq
leaq (%rdi,%rsi,4), %rsi
leaq (%rdx,%rcx,4), %rcx
movq %r8, %rax
movl (%rdx), %r9d
movl (%rdi), %r10d
cmpl %r9d, %r10d
jb 0x44c4
movl (%rdx), %r9d
cmpl %r9d, %r10d
jbe 0x44c2
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x44af
jmp 0x44e8
je 0x44cf
addq $0x4, %rdi
cmpq %rsi, %rdi
jne 0x44a7
jmp 0x44e8
movl %r10d, (%rax)
addq $0x4, %rax
addq $0x4, %rdi
cmpq %rsi, %rdi
je 0x44e8
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x44a4
subq %r8, %rax
sarq $0x2, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ralgond[P]SortedListIntersection/algo_scalar.cpp
// Function: match_scalar(unsigned int const*, unsigned long, unsigned int const*, unsigned long, unsigned int*)
size_t match_scalar(const uint32_t *A, const size_t lenA, const uint32_t *B, const size_t lenB, uint32_t *out) {

  const uint32_t *initout = out;
  if (lenA == 0 || lenB == 0)
    return 0;

  const uint32_t *endA = A + lenA;
  const uint32_t *endB = B + lenB;

  while (1) {
    while (*A < *B) {
    SKIP_FIRST_COMPARE:
      if (++A == endA)
        goto FINISH;
    }
    while (*A > *B) {
      if (++B == endB)
        goto FINISH;
    }
    if (*A == *B) {
      *out++ = *A;
      if (++A == endA || ++B == endB)
        goto FINISH;
    } else {
      goto SKIP_FIRST_COMPARE;
    }
  }

FINISH:
  return (out - initout);
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rcx, %rcx
sete %r9b
orb %al, %r9b
je 0x4505
xorl %eax, %eax
retq
leaq (%rdi,%rsi,4), %rsi
leaq (%rdx,%rcx,4), %rcx
movq %r8, %rax
movl (%rdx), %r9d
movl (%rdi), %r10d
cmpl %r9d, %r10d
jb 0x4530
movl (%rdx), %r9d
cmpl %r9d, %r10d
jbe 0x452e
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x451b
jmp 0x4554
je 0x453b
addq $0x4, %rdi
cmpq %rsi, %rdi
jne 0x4513
jmp 0x4554
movl %r10d, (%rax)
addq $0x4, %rax
addq $0x4, %rdi
cmpq %rsi, %rdi
je 0x4554
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x4510
subq %r8, %rax
sarq $0x2, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ralgond[P]SortedListIntersection/sorted_int_file_reader.cpp
// Function: read_sorted_int_from_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int*)
uint32_t* read_sorted_int_from_file(string filepath, uint32_t* size) {
	ifstream inf(filepath);
	if (inf) {
		vector<uint32_t> v;
		string line;
		while (getline(inf, line)) {
			int num = atoi(line.c_str());
			v.push_back(num);
		}

		*size = v.size();
		uint32_t* ret = new uint32_t[*size];
		for (int i = 0; i < v.size(); i++) {
			ret[i] = v.at(i);
		}
		return ret;
	} else {
		return NULL;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
leaq 0x50(%rsp), %r14
movl $0x8, %edx
movq %rsi, %rbx
movq %rdi, %rsi
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x70(%rsp,%rax)
je 0x553e
xorl %ebx, %ebx
jmp 0x5656
leaq 0x40(%rsp), %rbp
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %r14
leaq 0x50(%rsp), %r15
leaq 0x30(%rsp), %r12
leaq 0xc(%rsp), %r13
xorl %ecx, %ecx
movq %rbp, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
vmovaps %xmm0, (%r14)
movq %rcx, 0x10(%r14)
movb $0x0, (%rbp)
leaq 0x50(%rsp,%rax), %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x55da
movq 0x30(%rsp), %rdi
callq 0x21a0
movq 0x18(%rsp), %rsi
movl %eax, 0xc(%rsp)
cmpq 0x20(%rsp), %rsi
je 0x55c4
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x55cf
movq %r14, %rdi
movq %r13, %rdx
callq 0x56bc
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rax
jmp 0x5572
movq 0x18(%rsp), %r12
movq 0x10(%rsp), %r14
movabsq $0x3fffffffc, %rdi      # imm = 0x3FFFFFFFC
movq %r12, %r15
subq %r14, %r15
andq %r15, %rdi
sarq $0x2, %r15
movl %r15d, (%rbx)
callq 0x2030
movq %rax, %rbx
cmpq %r14, %r12
je 0x5625
cmpq $0x1, %r15
movq %rbx, %rdi
movq %r14, %rsi
adcq $0x0, %r15
shlq $0x2, %r15
movq %r15, %rdx
callq 0x2110
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5641
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2170
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x5656
movq 0x20(%rsp), %rsi
movq %r14, %rdi
subq %r14, %rsi
callq 0x2170
leaq 0x50(%rsp), %rdi
callq 0x2050
movq %rbx, %rax
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5679
jmp 0x5679
movq 0x30(%rsp), %rdi
movq %rax, %rbx
cmpq %rbp, %rdi
je 0x5693
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2170
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x56aa
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x50(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/ralgond[P]SortedListIntersection/utils.cpp
// Function: bisearch(unsigned int const*, unsigned int, unsigned int)
int bisearch(const uint32_t* a, uint32_t a_len, uint32_t target) {
	int low = 0;
	int high = a_len - 1;

	while (high-low > 4) {
		int mid = low + (high-low) / 2;
		int mid_v = a[mid];
		if (mid_v == target)
			return mid;
		else if (target < mid_v)
			high = mid - 1;
		else
			low = mid + 1;
	}

	int i = low;
	for (; i<=high; i++) {
		if (!(a[i] < target))
			break;
	}

	if (a[i] == target)
		return i;
	else
		return -1*(i+1);
}

// Assembly:
movl %esi, %eax
decl %eax
xorl %ecx, %ecx
cmpl $0x5, %eax
jl 0x5801
xorl %ecx, %ecx
movl %eax, %esi
shrl %eax
addl %ecx, %eax
movl (%rdi,%rax,4), %r8d
cmpl %edx, %r8d
je 0x582e
ja 0x57f2
incl %eax
movl %eax, %ecx
jmp 0x57f6
decl %eax
movl %eax, %esi
movl %esi, %eax
subl %ecx, %eax
cmpl $0x4, %eax
jg 0x57dd
jmp 0x5803
movl %eax, %esi
cmpl %esi, %ecx
jg 0x581f
movl %ecx, %eax
leaq (%rdi,%rax,4), %rax
incl %esi
cmpl %edx, (%rax)
jae 0x581f
incl %ecx
addq $0x4, %rax
cmpl %ecx, %esi
jne 0x580f
movl %esi, %ecx
movslq %ecx, %rax
xorl %ecx, %ecx
cmpl %edx, (%rdi,%rax,4)
setne %cl
negl %ecx
xorl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/kdungs[P]codecon/src/rugby.cc
// Function: main
int main() {
  int score;
  std::cin >> score;

  for (auto co = 0; co <= score / 7; ++co) {
    const auto afterCo = score - 7 * co;
    for (auto tr = 0; tr <= afterCo / 3; ++tr) {
      const auto afterTr = afterCo - 3 * tr;
      if (afterTr % 2 == 0) {
        auto ki = afterTr / 2;
        std::cout << co << ' ' << tr << ' ' << ki << '\n';
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x2e1f(%rip), %rdi      # 0x3fe0
leaq 0x14(%rsp), %rbx
movq %rbx, %rsi
callq 0x1030
movl (%rbx), %ebx
cmpl $-0x6, %ebx
jl 0x12cf
xorl %esi, %esi
movb $0x20, %r12b
xorl %r13d, %r13d
leal (,%r13,8), %ecx
movl %r13d, %eax
subl %ecx, %eax
addl %ebx, %eax
cmpl $-0x2, %eax
jl 0x12a2
cltq
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x20, %rcx
shrq $0x3f, %rax
leal (%rcx,%rax), %r15d
incl %r15d
movl %esi, 0x10(%rsp)
addl %esi, %ebx
xorl %ebp, %ebp
testb $0x1, %bl
jne 0x1290
movl %ebx, %r14d
sarl %r14d
movq 0x2da2(%rip), %rdi      # 0x3fd0
movl %r13d, %esi
callq 0x1070
movb %r12b, 0xd(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0xd(%rsp), %rsi
callq 0x1050
movq %rax, %rdi
movl %ebp, %esi
callq 0x1070
movb %r12b, 0xe(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0xe(%rsp), %rsi
callq 0x1050
movq %rax, %rdi
movl %r14d, %esi
callq 0x1070
movb $0xa, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0xf(%rsp), %rsi
callq 0x1050
incl %ebp
addl $-0x3, %ebx
cmpl %ebp, %r15d
jne 0x121c
movl 0x14(%rsp), %ebx
movl 0x10(%rsp), %esi
leal 0x1(%r13), %eax
movslq %ebx, %rcx
imulq $-0x6db6db6d, %rcx, %rdx # imm = 0x92492493
shrq $0x20, %rdx
addl %edx, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x2, %ecx
addl %edx, %ecx
addl $-0x7, %esi
cmpl %ecx, %r13d
movl %eax, %r13d
jl 0x11e1
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/token.cpp
// Function: operator<<(std::ostream&, Token&)
ostream& operator<< (ostream &os, Token& a)
{
   os << "Token: " << spellS(a.getSymbol()) << endl
      << "\tAttributes: " << endl
      << "\t\tLexeme: " << a.getLexeme() << endl
      << "\t\tValue: " << a.getValue() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xec40(%rip), %rsi      # 0x13383
movl $0x7, %edx
callq 0x2210
movl 0x28(%rbx), %esi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x4388
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2210
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %rax, %r14
leaq 0xebec(%rip), %rsi      # 0x1338b
movl $0xd, %edx
movq %rax, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %rax, %r14
leaq 0xebbc(%rip), %rsi      # 0x13399
movl $0xa, %edx
movq %rax, %rdi
callq 0x2210
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0x424c
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %r14, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20e0
movq %rax, %r14
leaq 0xeb7c(%rip), %rsi      # 0x133a4
movl $0x9, %edx
movq %rax, %rdi
callq 0x2210
movl (%rbx), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x20e0
leaq -0x38(%rbp), %rdi
callq 0x20c0
leaq -0x58(%rbp), %rdi
callq 0x20c0
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4871
callq 0x21b0
jmp 0x4871
jmp 0x486e
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4883
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop