LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movl %esi, %r12d
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq %r13, %r12
je 0x24e1
movzwl 0x2(%rbx,%r13,4), %r14d
testq %rbp, %rbp
je 0x2498
testq %r15, %r15
je 0x2503
cmpw %r14w, 0xe(%r15)
jne 0x24bb
incw 0xc(%r15)
jmp 0x24dc
pushq $0x10
popq %rdi
callq 0x21b0
andq $0x0, (%rax)
movl %r13d, 0x8(%rax)
movw $0x1, 0xc(%rax)
movq %rax, %r15
movq %rax, %rbp
movw %r14w, 0xe(%rax)
jmp 0x24dc
pushq $0x10
popq %rdi
callq 0x21b0
andq $0x0, (%rax)
movl %r13d, 0x8(%rax)
movw $0x1, 0xc(%rax)
movw %r14w, 0xe(%rax)
movq %rax, (%r15)
movq %rax, %r15
incq %r13
jmp 0x2475
pushq $0x18
popq %rdi
callq 0x21b0
movq %rbp, (%rax)
movq %rbx, 0x8(%rax)
movl %r12d, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b36(%rip), %rdi      # 0x6040
leaq 0x3b3c(%rip), %rsi      # 0x604d
leaq 0x3b44(%rip), %rcx      # 0x605c
pushq $0x1b
popq %rdx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq 0x6aac(%rip), %r14      # 0x8fd8
leaq 0x4395(%rip), %r15      # 0x68c8
movq %rdi, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2596
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x2100
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
movzwl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x2240
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
movq (%rax), %rcx
movq %rax, %rdi
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movzwl 0xe(%rbx), %esi
callq 0x2240
movq %rax, %rdi
callq 0x20c0
jmp 0x2536
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq 0x6a2d(%rip), %r14      # 0x8fd8
movq %rdi, %rbx
movq %rdi, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x25ed
movl 0x8(%r15), %eax
movslq %eax, %r12
movzwl 0xc(%r15), %ecx
addl %eax, %ecx
cmpl %r12d, %ecx
jbe 0x25b1
movq 0x8(%rbx), %rax
movq %r14, %rdi
movl (%rax,%r12,4), %esi
callq 0x2100
movq %rax, %rdi
callq 0x20c0
movl 0x8(%r15), %eax
incq %r12
jmp 0x25c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %ecx, %r15d
movl %ecx, -0x24(%rsp)
movq 0x6b7f(%rip), %rcx      # 0x9190
movl %esi, %ebp
andl $-0x8, %ebp
andl $-0x8, %r15d
shll $0x10, %r9d
movl $0x8, %eax
movq %r8, %r10
movq %rdx, %r11
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %r8, -0x20(%rsp)
cmpl %ebp, %r14d
jae 0x26cb
cmpl %r15d, %ebx
jae 0x26cb
movl %r14d, %edx
vmovdqu (%rdi,%rdx,4), %ymm0
movl %ebx, %edx
vpmovdw %ymm0, %xmm1
vmovdqu (%r11,%rdx,4), %ymm0
movl %eax, %edx
vpmovdw %ymm0, %xmm2
vpcmpestrm $0x1, %xmm1, %xmm2
vmovd %xmm0, %edx
movslq %edx, %r13
popcntl %r13d, %edx
shlq $0x4, %r13
vpshufb (%rcx,%r13), %xmm1, %xmm0
xorl %r13d, %r13d
vmovdqa %xmm0, -0x18(%rsp)
cmpq %r13, %rdx
je 0x26a2
movzwl -0x18(%rsp,%r13,2), %r8d
incq %r13
orl %r9d, %r8d
movl %r8d, (%r10)
addq $0x4, %r10
jmp 0x2688
vpextrw $0x7, %xmm2, %edx
vpextrw $0x7, %xmm1, %r13d
xorl %r12d, %r12d
xorl %r8d, %r8d
cmpw %dx, %r13w
setae %r12b
setbe %r8b
leal (%r14,%r8,8), %r14d
leal (%rbx,%r12,8), %ebx
jmp 0x2633
movl -0x24(%rsp), %ecx
movl %ebx, %ebx
movl %r14d, %r14d
cmpl %esi, %r14d
jae 0x26fe
cmpl %ecx, %ebx
jae 0x26fe
movl (%rdi,%r14,4), %eax
cmpl (%r11,%rbx,4), %eax
jae 0x26ec
incq %r14
jmp 0x26d4
jbe 0x26f2
incl %ebx
jmp 0x26cf
movl %eax, (%r10)
addq $0x4, %r10
incl %r14d
jmp 0x26ee
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_O2/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq %rdi, %r12
movq %rsi, %r13
movq (%r13), %r13
movq (%r12), %r12
testq %r12, %r12
je 0x2793
testq %r13, %r13
je 0x2793
movzwl 0xe(%r12), %eax
cmpw 0xe(%r13), %ax
je 0x275b
jb 0x2738
movq (%r13), %r13
jmp 0x273c
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 0x25f9
addl %eax, %ebp
jmp 0x2734
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_O2/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 0x69d5(%rip), %rax      # 0x9190
vpcmpeqd %xmm0, %xmm0, %xmm0
xorl %ecx, %ecx
cmpq $0x100, %rcx            # imm = 0x100
je 0x2814
movb $0x1, %sil
vmovdqa %xmm0, -0x18(%rsp)
xorl %edx, %edx
xorl %edi, %edi
cmpl $0x8, %edx
je 0x27fd
btl %edx, %ecx
jae 0x27f5
movslq %edi, %r8
leal -0x1(%rsi), %edi
movb %dil, -0x18(%rsp,%r8)
leal 0x2(%r8), %edi
movb %sil, -0x17(%rsp,%r8)
incl %edx
addb $0x2, %sil
jmp 0x27d7
vmovaps -0x18(%rsp), %xmm1
movq %rcx, %rdx
shlq $0x4, %rdx
incq %rcx
vmovaps %xmm1, (%rax,%rdx)
jmp 0x27c1
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
callq 0x27b4
pushq $0x10
popq %rdi
callq 0x2030
vpmovsxbw 0x37fd(%rip), %xmm1 # 0x6030
vpmovsxbw 0x37fc(%rip), %xmm0 # 0x6038
movq %rax, %rbx
pushq $0x8
popq %rax
movl %eax, %edx
vpcmpestrm $0x1, %xmm1, %xmm0
movq 0x693f(%rip), %rcx      # 0x9190
movq 0x6780(%rip), %r15      # 0x8fd8
leaq 0x382f(%rip), %rsi      # 0x608e
movq %r15, %rdi
vmovd %xmm0, %eax
cltq
popcntl %eax, %r14d
shlq $0x4, %rax
vpshufb (%rcx,%rax), %xmm1, %xmm0
vmovdqu %xmm0, (%rbx)
callq 0x21a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
movq %rax, %rdi
callq 0x20c0
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x28b5
movzwl (%rbx,%r12,2), %esi
movq %r15, %rdi
callq 0x2240
movq %rax, %rdi
callq 0x20c0
incq %r12
jmp 0x2896
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
vmovaps 0x37ea(%rip), %xmm0     # 0x60c0
leaq 0x10(%rsp), %rdi
movabsq $-0x12cfffc012cfffe, %rax # imm = 0xFED30003FED30002
movq %rax, 0x10(%rdi)
vmovaps %xmm0, (%rdi)
pushq $0x6
popq %rsi
callq 0x245c
movq %rax, %rdi
movq %rax, %r14
callq 0x2520
movabsq $-0x12cfffe012fefff, %rax # imm = 0xFED30001FED01001
movq %rsp, %rdi
movl $0xfed30003, 0x8(%rdi)  # imm = 0xFED30003
movq %rax, (%rdi)
pushq $0x3
popq %rsi
callq 0x245c
movq %rax, %rdi
movq %rax, %r15
callq 0x2520
pushq $0x18
popq %rdi
callq 0x2030
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2718
movq 0x668e(%rip), %r15      # 0x8fd8
movl %eax, %r14d
movq %r14, %rsi
movq %r15, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x20c0
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x2998
movq (%r15), %rax
movl (%rbx,%r12,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 0x2100
movq %rax, %rdi
callq 0x20c0
incq %r12
jmp 0x2963
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2b44
andl $0x0, (%r14)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x21d0
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x4d38
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x20b0
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x245c
movq %rax, %rdi
callq 0x259c
leaq 0x28(%rsp), %rdi
callq 0x20b0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x20b0
jmp 0x2a2f
jmp 0x2a2c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
callq 0x27b4
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %rax
leaq 0x368f(%rip), %rdx      # 0x60f0
xorl %ecx, %ecx
vmovaps %xmm0, (%rax)
cmpq $0x20, %rcx
je 0x2a7e
movzwl (%rcx,%rdx), %esi
addq $0x4, %rcx
movw %si, (%rax)
addq $0x2, %rax
jmp 0x2a67
vxorps %xmm0, %xmm0, %xmm0
leaq 0x3687(%rip), %rdx      # 0x6110
movq %rsp, %rax
xorl %ecx, %ecx
vmovaps %xmm0, (%rax)
cmpq $0x20, %rcx
je 0x2aa9
movzwl (%rcx,%rdx), %esi
addq $0x4, %rcx
movw %si, (%rax)
addq $0x2, %rax
jmp 0x2a92
pushq $0x10
popq %rdi
callq 0x2030
vmovdqa 0x10(%rsp), %xmm1
vmovdqa (%rsp), %xmm0
movq %rax, %rbx
pushq $0x8
popq %rax
movl %eax, %edx
vpcmpestrm $0x1, %xmm1, %xmm0
movq 0x66bf(%rip), %rcx      # 0x9190
movq 0x6500(%rip), %r15      # 0x8fd8
leaq 0x35af(%rip), %rsi      # 0x608e
movq %r15, %rdi
vmovd %xmm0, %eax
cltq
popcntl %eax, %r14d
shlq $0x4, %rax
vpshufb (%rcx,%rax), %xmm1, %xmm0
vmovdqu %xmm0, (%rbx)
callq 0x21a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
movq %rax, %rdi
callq 0x20c0
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x2b35
movzwl (%rbx,%r12,2), %esi
movq %r15, %rdi
callq 0x2240
movq %rax, %rdi
callq 0x20c0
incq %r12
jmp 0x2b16
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl %ecx, %r13d
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpq %rbx, %r13
je 0x2c64
movl (%r14,%rbx,4), %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x5004
testl %eax, %eax
js 0x2c5f
movl (%r14,%rbx,4), %eax
movq (%rsp), %rdx
movl %r12d, %ecx
incl %r12d
movl %eax, (%rdx,%rcx,4)
incq %rbx
jmp 0x2c37
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
xorl %r9d, %r9d
xorl %ebp, %ebp
xorl %eax, %eax
leal 0x1(%r9), %r11d
movl %r9d, %ebx
movl %ebp, %r10d
leal 0x1(%r10), %ebp
cmpl %esi, %ebp
jae 0x2d2e
cmpl %ecx, %r11d
jae 0x2d2e
movl %r10d, %r14d
movl (%rdi,%r14,4), %r12d
movl %ebp, %r14d
movl (%rdi,%r14,4), %ebp
movl (%rdx,%rbx,4), %r13d
movl (%rdx,%r11,4), %r14d
movl %eax, %r15d
cmpl %r13d, %r12d
jne 0x2cce
incl %eax
movl %r12d, (%r8,%r15,4)
jmp 0x2ce0
cmpl %r14d, %r12d
je 0x2d12
cmpl %r13d, %ebp
jne 0x2ce0
incl %eax
movl %ebp, (%r8,%r15,4)
jmp 0x2ce7
cmpl %r14d, %ebp
je 0x2cf2
jg 0x2d18
addl $0x2, %r10d
cmpl %esi, %r10d
jb 0x2c93
jmp 0x2d2e
movl %eax, %r11d
movl %ebp, (%r8,%r11,4)
incl %eax
leal 0x2(%r10), %ebp
addl $0x2, %r9d
cmpl %esi, %ebp
jae 0x2d2a
cmpl %ecx, %r9d
jb 0x2c89
jmp 0x2d2a
incl %eax
movl %r12d, (%r8,%r15,4)
addl $0x2, %r9d
movl %r10d, %ebp
cmpl %ecx, %r9d
jb 0x2c89
jmp 0x2d2e
addl $0x2, %r10d
movl %r9d, %r9d
movl %r10d, %r10d
cmpl %esi, %r10d
jae 0x2d5f
cmpl %ecx, %r9d
jae 0x2d5f
movl (%rdi,%r10,4), %r11d
cmpl (%rdx,%r9,4), %r11d
je 0x2d4f
jg 0x2d5a
incq %r10
jmp 0x2d34
movl %eax, %ebx
incl %eax
movl %r11d, (%r8,%rbx,4)
incl %r10d
incl %r9d
jmp 0x2d2e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
movq %rcx, %r14
movl %edx, 0x4(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
movl %r8d, %r15d
xorl %r13d, %r13d
pushq $0x4
popq %rbx
xorl %ebp, %ebp
cmpq %r13, %r15
je 0x2de2
movl (%r14,%r13,4), %eax
movq %r12, %rdi
movq %rsp, %rsi
movq %rbx, %rdx
movl %eax, (%rsp)
movq (%r12), %rax
callq *0x10(%rax)
testb %al, %al
je 0x2ddd
movl (%rsp), %edx
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x5004
testl %eax, %eax
js 0x2ddd
movl (%rsp), %eax
movq 0x8(%rsp), %rdx
movl %ebp, %ecx
incl %ebp
movl %eax, (%rdx,%rcx,4)
incq %r13
jmp 0x2d99
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x5f43(%rip), %rax      # 0x8d48
movq %rsp, %r15
movl %esi, %r12d
movq %rdi, %rbx
movq %r15, %rdi
movq %rax, (%r15)
movq $0x1, 0x8(%r15)
orq $-0x1, 0x10(%r15)
movl $0x1, 0x18(%r15)
orl $-0x1, 0x1c(%r15)
andl $0x0, 0x38(%r15)
andq $0x0, 0x40(%r15)
movabsq $0x3f1a36e2eb1c432d, %rax # imm = 0x3F1A36E2EB1C432D
movq %r12, 0x20(%r15)
movq %rax, 0x28(%r15)
movl $0xa5a5a5a5, %eax       # imm = 0xA5A5A5A5
movq %rax, 0x30(%r15)
callq 0x2eaa
pushq $0x68
popq %rdi
callq 0x21b0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x2fd0
jmp 0x2e7f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x307a
addq $0x4, %rbx
subq $0x1, %r12
jae 0x2e70
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r14, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
leaq 0x5da0(%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)
andq $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 0x3122
movq 0x40(%rbx), %rsi
leaq 0xf(%rsp), %rdx
movb $0x0, (%rdx)
shrq $0x3, %rsi
movq %r14, %rdi
callq 0x321a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x305a
movq %r14, %rdi
movq %rax, %r15
addq $0x8, %rbx
callq 0x377e
movq %rbx, %rdi
callq 0x3798
movq %r15, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/ralgond[P]SortedListIntersection/./bloom_filter.hpp
// Function: bloom_parameters::operator!()
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), %rcx
movb $0x1, %al
cmpq 0x10(%rdi), %rcx
jbe 0x30a3
retq
movl 0x18(%rdi), %ecx
decl %ecx
cmpl 0x1c(%rdi), %ecx
jae 0x30a2
cmpq $0x0, 0x20(%rdi)
je 0x30a2
movq 0x28(%rdi), %rcx
movabsq $0xfffffffffffff, %r8   # imm = 0xFFFFFFFFFFFFF
movq %rcx, %rdx
btrq $0x3f, %rdx
leaq -0x1(%rdx), %rsi
cmpq %r8, %rsi
movabsq $0x7ff0000000000000, %r8 # imm = 0x7FF0000000000000
setb %sil
testq %rcx, %rcx
sets %cl
andb %cl, %sil
cmpq %r8, %rdx
sete %r8b
orb %sil, %r8b
movabsq $-0x10000000000000, %rsi # imm = 0xFFF0000000000000
addq %rdx, %rsi
shrq $0x35, %rsi
cmpl $0x3ff, %esi            # imm = 0x3FF
setb %dl
andb %cl, %dl
orb %r8b, %dl
jne 0x30a2
movq 0x30(%rdi), %rax
incq %rax
cmpq $0x2, %rax
setb %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x10(%rsp), %rax
leaq 0x2eb4(%rip), %r12      # 0x6150
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
andq $0x0, (%rax)
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
xorl %eax, %eax
movq %rax, %rbp
movq 0x8(%r15), %rax
movq 0x10(%r15), %r13
subq %rax, %r13
sarq $0x2, %r13
cmpq %r13, %rbp
jae 0x3319
movl (%rax,%rbp,4), %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x37b6
movl %eax, 0x4(%rsp)
leaq 0x4(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movq (%r15), %rax
callq *0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%r15), %rcx
movq 0x8(%rsp), %rdx
shrq $0x3, %rax
movb (%rcx,%rax), %cl
leaq 0x1(%rbp), %rax
notb %cl
testb %cl, (%rdx,%r12)
je 0x32b4
cmpq %r13, %rbp
setae %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ralgond[P]SortedListIntersection/./bloom_filter.hpp
// Function: bloom_filter::hash_ap(unsigned char const*, unsigned long, unsigned int) const
inline bloom_type hash_ap(const unsigned char* begin, std::size_t remaining_length, bloom_type hash) const
   {
      const unsigned char* itr = begin;
      unsigned int loop        = 0;

      while (remaining_length >= 8)
      {
         const unsigned int& i1 = *(reinterpret_cast<const unsigned int*>(itr)); itr += sizeof(unsigned int);
         const unsigned int& i2 = *(reinterpret_cast<const unsigned int*>(itr)); itr += sizeof(unsigned int);

         hash ^= (hash <<  7) ^  i1 * (hash >> 3) ^
              (~((hash << 11) + (i2 ^ (hash >> 5))));

         remaining_length -= 8;
      }

      if (remaining_length)
      {
         if (remaining_length >= 4)
         {
            const unsigned int& i = *(reinterpret_cast<const unsigned int*>(itr));

            if (loop & 0x01)
               hash ^=    (hash <<  7) ^  i * (hash >> 3);
            else
               hash ^= (~((hash << 11) + (i ^ (hash >> 5))));

            ++loop;

            remaining_length -= 4;

            itr += sizeof(unsigned int);
         }

         if (remaining_length >= 2)
         {
            const unsigned short& i = *(reinterpret_cast<const unsigned short*>(itr));

            if (loop & 0x01)
               hash ^=    (hash <<  7) ^  i * (hash >> 3);
            else
               hash ^= (~((hash << 11) + (i ^ (hash >> 5))));

            ++loop;

            remaining_length -= 2;

            itr += sizeof(unsigned short);
         }

         if (remaining_length)
         {
            hash += ((*itr) ^ (hash * 0xA5A5A5A5)) + loop;
         }
      }

      return hash;
   }

// Assembly:
movl %ecx, %eax
xorl %edi, %edi
movq %rdx, %rcx
cmpq $0x8, %rcx
jb 0x3805
movl %eax, %r9d
shrl $0x3, %r9d
movl %eax, %r11d
shrl $0x5, %r11d
imull (%rsi,%rdi), %r9d
xorl 0x4(%rsi,%rdi), %r11d
movl %eax, %r10d
shll $0xb, %r10d
movl %eax, %r8d
shll $0x7, %r8d
addq $-0x8, %rcx
addq $0x8, %rdi
addl %r10d, %r11d
xorl %r8d, %r11d
xorl %r9d, %r11d
xorl %eax, %r11d
notl %r11d
movl %r11d, %eax
jmp 0x37bd
movq %rdi, %r8
subq %rdx, %r8
je 0x389a
cmpq $0x3, %rcx
ja 0x3846
addq %rdi, %rsi
leaq 0x1(%r8), %rdx
testq %rdx, %rdx
je 0x389b
movzwl (%rsi), %edi
movl %eax, %r8d
shrl $0x5, %r8d
movl %eax, %edx
shll $0xb, %edx
xorl %edi, %r8d
addl %edx, %r8d
xorl %eax, %r8d
notl %r8d
pushq $0x1
popq %rdx
movl %r8d, %eax
jmp 0x3888
leaq 0x4(%rsi,%rdi), %rsi
movl %eax, %r8d
shrl $0x5, %r8d
movl %eax, %ecx
shll $0xb, %ecx
subq %rdi, %rdx
xorl -0x4(%rsi), %r8d
addl %ecx, %r8d
movq %rdx, %rcx
addq $-0x4, %rcx
xorl %r8d, %eax
notl %eax
cmpq $0x2, %rcx
jb 0x3892
movzwl (%rsi), %edi
movl %eax, %edx
shll $0x7, %edx
xorl %eax, %edx
shrl $0x3, %eax
imull %edi, %eax
xorl %edx, %eax
pushq $0x2
popq %rdx
addq $-0x2, %rcx
addq $0x2, %rsi
jmp 0x3895
pushq $0x1
popq %rdx
testq %rcx, %rcx
jne 0x389d
retq
xorl %edx, %edx
movzbl (%rsi), %ecx
imull $0xa5a5a5a5, %eax, %esi # imm = 0xA5A5A5A5
addl %eax, %edx
xorl %ecx, %esi
addl %esi, %edx
movl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x10(%rsp), %rax
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %rbp
leaq 0x287c(%rip), %r13      # 0x6150
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
andq $0x0, (%rax)
andq $0x0, (%rcx)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jae 0x3946
movq (%rbx), %rdx
movl (%rax,%r12,4), %ecx
movq %r14, %rdi
movq %r15, %rsi
callq 0x37b6
movl %eax, 0x4(%rsp)
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %rbp, %rsi
movq (%r14), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%r14), %rdx
incq %r12
movb (%rax,%r13), %al
shrq $0x3, %rcx
orb %al, (%rdx,%rcx)
jmp 0x38e8
incq 0x50(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5599(%rip), %rcx      # 0x91c0
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x3c75
vmovdqu %ymm0, -0x28(%rsp)
xorl %edx, %edx
xorl %esi, %esi
cmpl $0x8, %edx
je 0x3c5e
btl %edx, %eax
jae 0x3c5a
movslq %esi, %rdi
movb %dl, -0x28(%rsp,%rdi)
andw $0x0, -0x27(%rsp,%rdi)
leal 0x4(%rdi), %esi
movb $0x0, -0x25(%rsp,%rdi)
incl %edx
jmp 0x3c3b
vmovups -0x28(%rsp), %ymm1
movq %rax, %rdx
shlq $0x5, %rdx
incq %rax
vmovaps %ymm1, (%rdx,%rcx)
jmp 0x3c29
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x48, %rsp
callq 0x3c1c
vmovups 0x28bf(%rip), %ymm0     # 0x66a0
vmovups 0x28d7(%rip), %ymm1     # 0x66c0
leaq 0x20(%rsp), %r14
movq %rsp, %r15
vmovups %ymm0, (%r14)
vmovups %ymm1, (%r15)
pushq $0x20
popq %rdi
vzeroupper
callq 0x2030
movq %rax, %rbx
pushq $0x8
popq %rcx
movq %r14, %rdi
movq %rcx, %rsi
movq %r15, %rdx
movq %rax, %r8
callq 0x3c79
movq 0x51b4(%rip), %r14      # 0x8fd8
leaq 0x2263(%rip), %rsi      # 0x608e
movq %rax, %r15
movq %r14, %rdi
callq 0x21a0
movl %r15d, %r15d
movq %rax, %rdi
movq %r15, %rsi
callq 0x2100
movq %rax, %rdi
callq 0x20c0
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x3e6d
movl (%rbx,%r12,4), %esi
movq %r14, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x20c0
incq %r12
jmp 0x3e4f
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7376(%rip), %rcx      # 0xb200
xorl %eax, %eax
cmpq $0x10000, %rax          # imm = 0x10000
je 0x3ee4
vmovdqu64 %zmm0, -0x48(%rsp)
xorl %edx, %edx
xorl %esi, %esi
cmpl $0x10, %edx
je 0x3ec6
btl %edx, %eax
jae 0x3ec2
movslq %esi, %rdi
movb %dl, -0x48(%rsp,%rdi)
andw $0x0, -0x47(%rsp,%rdi)
leal 0x4(%rdi), %esi
movb $0x0, -0x45(%rsp,%rdi)
incl %edx
jmp 0x3ea3
vmovups -0x48(%rsp), %zmm1
movq %rax, %rdx
shlq $0x6, %rdx
incq %rax
vmovaps %zmm1, (%rdx,%rcx)
jmp 0x3e8c
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4069
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 0x4094
movl (%rdx), %r9d
cmpl %r9d, %r10d
jbe 0x4092
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x407f
jmp 0x40b8
je 0x409f
addq $0x4, %rdi
cmpq %rsi, %rdi
jne 0x4077
jmp 0x40b8
movl %r10d, (%rax)
addq $0x4, %rax
addq $0x4, %rdi
cmpq %rsi, %rdi
je 0x40b8
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x4074
subq %r8, %rax
sarq $0x2, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x40d5
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 0x4100
movl (%rdx), %r9d
cmpl %r9d, %r10d
jbe 0x40fe
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x40eb
jmp 0x4124
je 0x410b
addq $0x4, %rdi
cmpq %rsi, %rdi
jne 0x40e3
jmp 0x4124
movl %r10d, (%rax)
addq $0x4, %rax
addq $0x4, %rdi
cmpq %rsi, %rdi
je 0x4124
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x40e0
subq %r8, %rax
sarq $0x2, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x48(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x68(%rsp,%rax)
je 0x4d73
xorl %ebx, %ebx
jmp 0x4e4d
leaq 0x10(%rsp), %r14
leaq 0x38(%rsp), %rax
vxorps %xmm0, %xmm0, %xmm0
leaq 0x48(%rsp), %r15
leaq 0x28(%rsp), %r12
leaq 0xc(%rsp), %r13
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
andq $0x0, 0x10(%r14)
vmovaps %xmm0, (%r14)
movb $0x0, (%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4dda
movq 0x28(%rsp), %rdi
callq 0x2200
movl %eax, 0xc(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x4ebc
jmp 0x4da6
movq 0x18(%rsp), %r12
movq 0x10(%rsp), %r13
movabsq $0x3fffffffc, %rdi      # imm = 0x3FFFFFFFC
movq %r12, %rax
subq %r13, %rax
andq %rax, %rdi
shrq $0x2, %rax
movl %eax, (%rbx)
callq 0x2030
leaq 0x10(%rsp), %r15
movq %rax, %rbx
xorl %r14d, %r14d
subq %r13, %r12
sarq $0x2, %r12
cmpq %r14, %r12
jbe 0x4e39
movq %r15, %rdi
movq %r14, %rsi
callq 0x4e9a
movl (%rax), %eax
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %r12
movl %eax, (%rbx,%r14,4)
incq %r14
jmp 0x4e0d
leaq 0x28(%rsp), %rdi
callq 0x20b0
leaq 0x10(%rsp), %rdi
callq 0x3798
leaq 0x48(%rsp), %rdi
callq 0x2050
movq %rbx, %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4e71
jmp 0x4e71
jmp 0x4e71
leaq 0x28(%rsp), %rdi
movq %rax, %rbx
callq 0x20b0
leaq 0x10(%rsp), %rdi
callq 0x3798
leaq 0x48(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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:
decl %esi
xorl %ecx, %ecx
movl %esi, %eax
subl %ecx, %eax
cmpl $0x4, %eax
jle 0x502c
shrl %eax
addl %ecx, %eax
movl (%rdi,%rax,4), %r8d
cmpl %edx, %r8d
je 0x505c
ja 0x5026
incl %eax
movl %eax, %ecx
jmp 0x5008
decl %eax
movl %eax, %esi
jmp 0x5008
movslq %esi, %rsi
movl %ecx, %ecx
leaq 0x1(%rsi), %rax
cmpq %rcx, %rax
cmovleq %rcx, %rax
cmpq %rsi, %rcx
jg 0x504e
cmpl %edx, (%rdi,%rcx,4)
jae 0x504b
incq %rcx
jmp 0x503c
movq %rcx, %rax
cltq
xorl %ecx, %ecx
cmpl %edx, (%rdi,%rax,4)
setne %cl
negl %ecx
xorl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq 0x2e22(%rip), %rdi      # 0x3fe0
leaq 0x4(%rsp), %rsi
callq 0x1030
xorl %ecx, %ecx
pushq $0x20
popq %rbp
xorl %r15d, %r15d
movl 0x4(%rsp), %r14d
movl %r14d, %eax
cltd
pushq $0x7
popq %rsi
idivl %esi
cmpl %eax, %r15d
jg 0x1269
imull $-0x7, %r15d, %eax
addl %r14d, %eax
cltd
pushq $0x3
popq %rsi
idivl %esi
movl %eax, %r13d
movl %ecx, (%rsp)
addl %ecx, %r14d
xorl %ebx, %ebx
cmpl %r13d, %ebx
jg 0x125b
testb $0x1, %r14b
jne 0x1253
movl %r14d, %r12d
sarl %r12d
movq 0x2db9(%rip), %rdi      # 0x3fd0
movl %r15d, %esi
callq 0x1070
movq %rax, %rdi
movl %ebp, %esi
callq 0x1050
movq %rax, %rdi
movl %ebx, %esi
callq 0x1070
movq %rax, %rdi
movl %ebp, %esi
callq 0x1050
movq %rax, %rdi
movl %r12d, %esi
callq 0x1070
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0x1050
incl %ebx
addl $-0x3, %r14d
jmp 0x11ff
incl %r15d
movl (%rsp), %ecx
addl $-0x7, %ecx
jmp 0x11d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/louisabraham[P]cage/./cage.hpp
// Function: luby(int)
long long luby(int x)
{
    // Find the finite subsequence that contains index 'x', and the
    // size of that subsequence:
    int size, seq;
    for (size = 1, seq = 0; size < x + 1; seq++, size = 2 * size + 1)
        ;

    while (size - 1 != x)
    {
        size = (size - 1) >> 1;
        seq--;
        x = x % size;
    }

    return 1LL << seq;
}

// Assembly:
movl %edi, %eax
xorl %ecx, %ecx
pushq $0x1
popq %rsi
cmpl %eax, %esi
jg 0x12bb
incl %ecx
leal 0x1(,%rsi,2), %esi
jmp 0x12a3
sarl %esi
decl %ecx
cltd
idivl %esi
movl %edx, %eax
decl %esi
cmpl %eax, %esi
jne 0x12b2
pushq $0x1
popq %rax
shlq %cl, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0xb88b(%rip), %rsi      # 0xf37d
callq 0x21a0
movq %rax, %r14
movl 0x28(%rbx), %esi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x3898
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20f0
leaq 0xb862(%rip), %rsi      # 0xf385
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
leaq 0xb859(%rip), %rsi      # 0xf393
movq %rax, %rdi
callq 0x21a0
movq %rax, %r14
leaq 0x8(%rbx), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2240
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20f0
leaq 0xb831(%rip), %rsi      # 0xf39e
movq %rax, %rdi
callq 0x21a0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
leaq -0x38(%rbp), %rdi
callq 0x20d0
leaq -0x58(%rbp), %rdi
callq 0x20d0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20d0
jmp 0x3bac
jmp 0x3ba9
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/symboltable.cpp
// Function: Symtable::search(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Symtable::search(string s)
{
   Token a;
   string comp;
   for (/*std::size_t*/int i = 0; i < 307; i++)//check all the loctions that are
      //occupied
   {
      a = htable[i];
      comp = a.getLexeme();
      if ( spellS (a.getSymbol()) != "NONAME")
      {
	 if ( comp == s )
	 {
	    return i;//if found return it's location
	 }
	 else
	    ;
      }
      else
	 ;
   }
   return -1;//return -1 if not found
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %r12
leaq -0x80(%rbp), %rdi
callq 0x7a46
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r15d, %r15d
leaq -0xa0(%rbp), %r14
xorl %ebx, %ebx
cmpq $0x133, %rbx            # imm = 0x133
je 0x7614
movq (%r12), %rsi
addq %r15, %rsi
leaq -0x80(%rbp), %rdi
callq 0x7aa8
movq %r14, %rdi
leaq -0x78(%rbp), %rsi
callq 0x2240
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x2210
movq %r14, %rdi
callq 0x20d0
movl -0x58(%rbp), %esi
movq %r14, %rdi
callq 0x3898
movq %r14, %rdi
leaq 0x7d20(%rip), %rsi      # 0xf305
callq 0x7a38
movl %eax, %r13d
movq %r14, %rdi
callq 0x20d0
testb %r13b, %r13b
je 0x760b
leaq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x7ac9
testb %al, %al
jne 0x7619
incq %rbx
addq $0x30, %r15
jmp 0x7597
pushq $-0x1
popq %rbx
jmp 0x7619
leaq -0x50(%rbp), %rdi
callq 0x20d0
leaq -0x78(%rbp), %rdi
callq 0x20d0
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7640
jmp 0x7640
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20d0
leaq -0x78(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/symboltable.cpp
// Function: Symtable::printTable()
void Symtable::printTable()
{
   Token a;
   for (std::size_t i = 0; i < 307; i++)
   {
      a = htable[i];
      if (spellS (a.getSymbol()) != "NONAME")
      {
	 cout << a;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x7a46
xorl %r12d, %r12d
leaq -0x78(%rbp), %r15
cmpq $0x3990, %r12           # imm = 0x3990
je 0x76f3
movq (%rbx), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x7aa8
movl -0x30(%rbp), %esi
movq %r15, %rdi
callq 0x3898
movq %r15, %rdi
leaq 0x7c3c(%rip), %rsi      # 0xf305
callq 0x7a38
movl %eax, %r13d
movq %r15, %rdi
callq 0x20d0
testb %r13b, %r13b
je 0x76ed
movq 0xd8e3(%rip), %rdi      # 0x14fc8
movq %r14, %rsi
callq 0x3adb
addq $0x30, %r12
jmp 0x769d
leaq -0x50(%rbp), %rdi
callq 0x20d0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x770d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
nop