LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_read_block
int bgzf_read_block(BGZF *fp)
{
	uint8_t header[BLOCK_HEADER_LENGTH], *compressed_block;
	int count, size = 0, block_length, remaining;
	int64_t block_address;
	block_address = _bgzf_tell((_bgzf_file_t)fp->fp);
	if (fp->cache_size && load_block_from_cache(fp, block_address)) return 0;
	count = _bgzf_read(fp->fp, header, sizeof(header));
	if (count == 0) { // no data read
		fp->block_length = 0;
		return 0;
	}
	if (count != sizeof(header) || !check_header(header)) {
		fp->errcode |= BGZF_ERR_HEADER;
		return -1;
	}
	size = count;
	block_length = unpackInt16((uint8_t*)&header[16]) + 1; // +1 because when writing this number, we used "-1"
	compressed_block = (uint8_t*)fp->compressed_block;
	memcpy(compressed_block, header, BLOCK_HEADER_LENGTH);
	remaining = block_length - BLOCK_HEADER_LENGTH;
	count = _bgzf_read(fp->fp, &compressed_block[BLOCK_HEADER_LENGTH], remaining);
	if (count != remaining) {
		fp->errcode |= BGZF_ERR_IO;
		return -1;
	}
	size += count;
	if ((count = inflate_block(fp, block_length)) < 0) return -1;
	if (fp->block_length != 0) fp->block_offset = 0; // Do not reset offset if this read follows a seek.
	fp->block_address = block_address;
	fp->block_length = count;
	cache_block(fp, size);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x5560
movq %rax, %r14
movq 0x30(%rbx), %rcx
movq %rsp, %rdi
movl $0x1, %esi
movl $0x12, %edx
callq 0x5630
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
andq %rax, %rcx
je 0x37870
cmpl $0x12, %ecx
jne 0x37866
cmpb $0x1f, (%rsp)
jne 0x37866
cmpb $-0x75, 0x1(%rsp)
jne 0x37866
cmpb $0x8, 0x2(%rsp)
jne 0x37866
testb $0x4, 0x3(%rsp)
je 0x37866
cmpw $0x6, 0xa(%rsp)
jne 0x37866
cmpb $0x42, 0xc(%rsp)
jne 0x37866
cmpb $0x43, 0xd(%rsp)
jne 0x37866
cmpw $0x2, 0xe(%rsp)
jne 0x37866
movzwl 0x10(%rsp), %r12d
movq 0x20(%rbx), %rdi
movzwl 0x10(%rsp), %eax
movw %ax, 0x10(%rdi)
movaps (%rsp), %xmm0
movups %xmm0, (%rdi)
leaq -0x11(%r12), %r15
addq $0x12, %rdi
movq 0x30(%rbx), %rcx
movl $0x1, %esi
movq %r15, %rdx
callq 0x5630
cmpl %eax, %r15d
jne 0x37889
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movups %xmm0, 0x40(%rdi)
movq 0x20(%rbx), %rax
addq $0x12, %rax
movq %rax, (%rdi)
addl $-0xf, %r12d
movl %r12d, 0x8(%rdi)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%rdi)
movl $0x10000, 0x20(%rdi)    # imm = 0x10000
leaq 0xd32(%rip), %rdx       # 0x38544
movl $0xfffffff1, %esi       # imm = 0xFFFFFFF1
movl $0x70, %ecx
callq 0x53c0
testl %eax, %eax
jne 0x3788e
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl $0x4, %esi
callq 0x5360
movl %eax, %ebp
xorl $0x1, %ebp
movq %r15, %rdi
callq 0x54a0
orl %ebp, %eax
jne 0x3788e
movl 0x48(%rsp), %eax
testl %eax, %eax
js 0x37869
cmpl $0x0, 0x8(%rbx)
je 0x3785d
movl $0x0, 0xc(%rbx)
movq %r14, 0x10(%rbx)
movl %eax, 0x8(%rbx)
jmp 0x37877
orb $0x2, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x37879
movl $0x0, 0x8(%rbx)
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
orb $0x4, (%rbx)
jmp 0x37869
orb $0x1, (%rbx)
jmp 0x37869
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_read
ssize_t bgzf_read(BGZF *fp, void *data, size_t length)
{
	ssize_t bytes_read = 0;
	uint8_t *output = (uint8_t*)data;
	if (length <= 0) return 0;
	assert(fp->is_write == 0);
	while (bytes_read < length) {
		int copy_length, available = fp->block_length - fp->block_offset;
		uint8_t *buffer;
		if (available <= 0) {
			if (bgzf_read_block(fp) != 0) return -1;
			available = fp->block_length - fp->block_offset;
			if (available <= 0) break;
		}
		copy_length = length - bytes_read < available? length - bytes_read : available;
		buffer = (uint8_t*)fp->uncompressed_block;
		memcpy(output, buffer + fp->block_offset, copy_length);
		fp->block_offset += copy_length;
		output += copy_length;
		bytes_read += copy_length;
	}
	if (fp->block_offset == fp->block_length) {
		fp->block_address = _bgzf_tell((_bgzf_file_t)fp->fp);
		fp->block_offset = fp->block_length = 0;
	}
	return bytes_read;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x37936
movq %rdi, %r14
testb $0x3, 0x2(%rdi)
jne 0x3794e
movq %rdx, %r15
movq %rsi, %r12
movl 0xc(%r14), %eax
xorl %ebx, %ebx
movl 0x8(%r14), %edx
subl %eax, %edx
jg 0x378e0
movq %r14, %rdi
callq 0x376fc
testl %eax, %eax
jne 0x3793a
movl 0x8(%r14), %ecx
movl 0xc(%r14), %eax
movl %ecx, %edx
subl %eax, %edx
jle 0x3791b
movq %r15, %r13
subq %rbx, %r13
movl %edx, %ecx
cmpq %rcx, %r13
cmovaeq %rcx, %r13
movslq %eax, %rsi
addq 0x18(%r14), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x5380
movl 0xc(%r14), %eax
addl %r13d, %eax
movl %eax, 0xc(%r14)
addq %r13, %r12
addq %r13, %rbx
cmpq %r15, %rbx
jb 0x378be
movl 0x8(%r14), %ecx
cmpl %ecx, %eax
jne 0x37941
movq 0x30(%r14), %rdi
callq 0x5560
movq %rax, 0x10(%r14)
movq $0x0, 0x8(%r14)
jmp 0x37941
xorl %ebx, %ebx
jmp 0x37941
movq $-0x1, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3389(%rip), %rdi      # 0x3acde
leaq 0x3329(%rip), %rsi      # 0x3ac85
leaq 0x338d(%rip), %rcx      # 0x3acf0
movl $0x162, %edx            # imm = 0x162
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_flush
int bgzf_flush(BGZF *fp)
{
	if (!fp->is_write) return 0;
#ifdef BGZF_MT
	if (fp->mt) return mt_flush(fp);
#endif
	while (fp->block_offset > 0) {
		int block_length;
		block_length = deflate_block(fp, fp->block_offset);
		if (block_length < 0) return -1;
		if (fwrite(fp->compressed_block, 1, block_length, (FILE*)fp->fp) != (size_t)block_length) {
			fp->errcode |= BGZF_ERR_IO; // possibly truncated file
			return -1;
		}
		fp->block_address += block_length;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testb $0x3, 0x2(%rdi)
je 0x379ba
movq %rdi, %rbx
movl 0xc(%rdi), %esi
testl %esi, %esi
jle 0x379ba
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x379c8
testl %eax, %eax
js 0x379bc
movl %eax, %r14d
movq 0x20(%rbx), %rdi
movq 0x30(%rbx), %rcx
movl $0x1, %esi
movq %r14, %rdx
callq 0x5880
cmpq %r14, %rax
jne 0x379c3
addq %r14, 0x10(%rbx)
movl 0xc(%rbx), %esi
testl %esi, %esi
jg 0x37986
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
orb $0x4, (%rbx)
jmp 0x379bc
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: deflate_block
static int deflate_block(BGZF *fp, int block_length)
{
	int comp_size = BGZF_MAX_BLOCK_SIZE;
	if (bgzf_compress(fp->compressed_block, &comp_size, fp->uncompressed_block, block_length, fp->compress_level) != 0) {
		fp->errcode |= BGZF_ERR_ZLIB;
		return -1;
	}
	fp->block_offset = 0;
	return comp_size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %esi, %eax
movq %rdi, %rbx
movq 0x20(%rdi), %r12
movq 0x18(%rdi), %r14
movl (%rdi), %esi
sarl $0x14, %esi
xorps %xmm0, %xmm0
movq %rsp, %rdi
movups %xmm0, 0x40(%rdi)
movq %r14, (%rdi)
movl %eax, %r15d
movl %eax, 0x8(%rdi)
leaq 0x12(%r12), %rax
movq %rax, 0x18(%rdi)
movl $0xffe6, 0x20(%rdi)     # imm = 0xFFE6
leaq 0xb34(%rip), %rax       # 0x38544
movl $0x8, %edx
movl $0xfffffff1, %ecx       # imm = 0xFFFFFFF1
movl $0x8, %r8d
xorl %r9d, %r9d
pushq $0x70
pushq %rax
callq 0x5070
addq $0x10, %rsp
testl %eax, %eax
jne 0x37a51
movq %rsp, %rdi
movl $0x4, %esi
callq 0x51a0
cmpl $0x1, %eax
jne 0x37a51
movq %rsp, %rdi
callq 0x5220
testl %eax, %eax
je 0x37a68
orb $0x1, (%rbx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x28(%rsp), %eax
leal 0x1a(%rax), %ebp
movaps 0x330a(%rip), %xmm0     # 0x3ad80
movups %xmm0, (%r12)
addl $0x19, %eax
movw %ax, 0x10(%r12)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5300
movq %rax, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x5300
movslq %ebp, %rcx
movq %r12, %rsi
movb %al, -0x8(%r12,%rcx)
movb %ah, -0x7(%rsi,%rcx)
movl %eax, %edx
shrl $0x10, %edx
movb %dl, -0x6(%r12,%rcx)
shrl $0x18, %eax
movb %al, -0x5(%r12,%rcx)
movl %r15d, %edx
movb %dl, -0x4(%r12,%rcx)
movb %dh, -0x3(%rsi,%rcx)
movl %r15d, %eax
shrl $0x10, %eax
movb %al, -0x2(%r12,%rcx)
shrl $0x18, %edx
movb %dl, -0x1(%r12,%rcx)
movl $0x0, 0xc(%rbx)
jmp 0x37a59
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_write
ssize_t bgzf_write(BGZF *fp, const void *data, size_t length)
{
	const uint8_t *input = (const uint8_t*)data;
	int block_length = BGZF_BLOCK_SIZE, bytes_written = 0;
	assert(fp->is_write);
#ifdef BGZF_MT
	if (fp->mt) return mt_write(fp, data, length);
#endif
	while (bytes_written < length) {
		uint8_t* buffer = (uint8_t*)fp->uncompressed_block;
		int copy_length = block_length - fp->block_offset < length - bytes_written? block_length - fp->block_offset : length - bytes_written;
		memcpy(buffer + fp->block_offset, input, copy_length);
		fp->block_offset += copy_length;
		input += copy_length;
		bytes_written += copy_length;
		if (fp->block_offset == block_length && bgzf_flush(fp)) break;
	}
	return bytes_written;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testb $0x3, 0x2(%rdi)
je 0x37b8d
movq %rdx, %r14
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x37b80
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
movslq 0xc(%r12), %rdi
movl $0xff00, %ecx           # imm = 0xFF00
subq %rdi, %rcx
movq %r14, %rdx
subq %rax, %rdx
cmpq %rcx, %rdx
cmoval %ecx, %edx
addq 0x18(%r12), %rdi
movslq %edx, %r13
movq %r15, %rsi
movq %r13, %rdx
callq 0x5380
addl %r13d, %ebx
movl 0xc(%r12), %eax
addl %r13d, %eax
movl %eax, 0xc(%r12)
addq %r13, %r15
cmpl $0xff00, %eax           # imm = 0xFF00
jne 0x37b75
movq %r12, %rdi
callq 0x3796d
testl %eax, %eax
jne 0x37b7d
movslq %ebx, %rax
cmpq %r14, %rax
jb 0x37b23
movslq %ebx, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3186(%rip), %rdi      # 0x3ad1a
leaq 0x30ea(%rip), %rsi      # 0x3ac85
leaq 0x3185(%rip), %rcx      # 0x3ad27
movl $0x239, %edx            # imm = 0x239
callq 0x5280
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_close
int bgzf_close(BGZF* fp)
{
	int ret, block_length;
	if (fp == 0) return -1;
	if (fp->is_write) {
		if (bgzf_flush(fp) != 0) return -1;
		fp->compress_level = -1;
		block_length = deflate_block(fp, 0); // write an empty block
		fwrite(fp->compressed_block, 1, block_length, (FILE*)fp->fp);
		if (fflush((FILE*)fp->fp) != 0) {
			fp->errcode |= BGZF_ERR_IO;
			return -1;
		}
#ifdef BGZF_MT
		if (fp->mt) mt_destroy((mtaux_t*)fp->mt);
#endif
	}
	ret = fp->is_write? fclose((FILE*)fp->fp) : _bgzf_close(fp->fp);
	if (ret != 0) return -1;
	free(fp->uncompressed_block);
	free(fp->compressed_block);
	free_cache(fp);
	free(fp);
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x37c2e
movq %rdi, %rbx
testb $0x3, 0x2(%rdi)
je 0x37c05
movq %rbx, %rdi
callq 0x3796d
testl %eax, %eax
jne 0x37c2e
orl $0xfff00000, (%rbx)     # imm = 0xFFF00000
movq %rbx, %rdi
xorl %esi, %esi
callq 0x379c8
movslq %eax, %rdx
movq 0x20(%rbx), %rdi
movq 0x30(%rbx), %rcx
movl $0x1, %esi
callq 0x5880
movq 0x30(%rbx), %rdi
callq 0x5510
testl %eax, %eax
je 0x37c05
orb $0x4, (%rbx)
jmp 0x37c2e
movq 0x30(%rbx), %rdi
callq 0x5450
testl %eax, %eax
jne 0x37c2e
movq 0x18(%rbx), %rdi
callq 0x5530
movq 0x20(%rbx), %rdi
callq 0x5530
movq %rbx, %rdi
callq 0x5530
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_check_EOF
int bgzf_check_EOF(BGZF *fp)
{
	uint8_t buf[28];
	off_t offset;
	offset = _bgzf_tell((_bgzf_file_t)fp->fp);
	if (_bgzf_seek(fp->fp, -28, SEEK_END) < 0) return 0;
	_bgzf_read(fp->fp, buf, 28);
	_bgzf_seek(fp->fp, offset, SEEK_SET);
	return (memcmp("\037\213\010\4\0\0\0\0\0\377\6\0\102\103\2\0\033\0\3\0\0\0\0\0\0\0\0\0", buf, 28) == 0)? 1 : 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x5560
movq %rax, %r14
movq 0x30(%rbx), %rdi
movq $-0x1c, %rsi
movl $0x2, %edx
callq 0x5210
testl %eax, %eax
js 0x37cc8
movq 0x30(%rbx), %rcx
movq %rsp, %r15
movl $0x1, %esi
movl $0x1c, %edx
movq %r15, %rdi
callq 0x5630
movq 0x30(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5210
movdqu 0xc(%r15), %xmm0
pcmpeqb 0x2f8a(%rip), %xmm0     # 0x3ac30
movdqa (%r15), %xmm1
pcmpeqb 0x2f8d(%rip), %xmm1     # 0x3ac40
pand %xmm0, %xmm1
pmovmskb %xmm1, %ecx
xorl %eax, %eax
cmpl $0xffff, %ecx           # imm = 0xFFFF
sete %al
jmp 0x37cca
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_seek
int64_t bgzf_seek(BGZF* fp, int64_t pos, int where)
{
	int block_offset;
	int64_t block_address;

	if (fp->is_write || where != SEEK_SET) {
		fp->errcode |= BGZF_ERR_MISUSE;
		return -1;
	}
	block_offset = pos & 0xFFFF;
	block_address = pos >> 16;
	if (_bgzf_seek(fp->fp, block_address, SEEK_SET) < 0) {
		fp->errcode |= BGZF_ERR_IO;
		return -1;
	}
	fp->block_length = 0;  // indicates current block has not been loaded
	fp->block_address = block_address;
	fp->block_offset = block_offset;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %ecx
andl $0x30000, %ecx          # imm = 0x30000
orl %edx, %ecx
je 0x37cf8
orl $0x8, %eax
movl %eax, (%rbx)
movq $-0x1, %rax
jmp 0x37d28
movq %rsi, %r14
movq %rsi, %r15
sarq $0x10, %r15
movq 0x30(%rbx), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x5210
testl %eax, %eax
js 0x37d2e
movzwl %r14w, %eax
movl $0x0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movl %eax, 0xc(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
orb $0x4, (%rbx)
jmp 0x37cef
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_is_bgzf
int bgzf_is_bgzf(const char *fn)
{
	uint8_t buf[16];
	int n;
	_bgzf_file_t fp;
	if ((fp = _bgzf_open(fn, "r")) == 0) return 0;
	n = _bgzf_read(fp, buf, 16);
	_bgzf_close(fp);
	if (n != 16) return 0;
	return memcmp(g_magic, buf, 16) == 0? 1 : 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xeab(%rip), %rsi       # 0x38bee
callq 0x5520
xorl %ebx, %ebx
testq %rax, %rax
je 0x37d93
movq %rax, %r14
movq %rsp, %rdi
movl $0x1, %esi
movl $0x10, %edx
movq %rax, %rcx
callq 0x5630
movq %rax, %r15
movq %r14, %rdi
callq 0x5450
cmpl $0x10, %r15d
jne 0x37d93
movdqa (%rsp), %xmm0
pcmpeqb 0x2ebb(%rip), %xmm0     # 0x3ac40
pmovmskb %xmm0, %eax
xorl %ebx, %ebx
cmpl $0xffff, %eax           # imm = 0xFFFF
sete %bl
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_getc
int bgzf_getc(BGZF *fp)
{
	int c;
	if (fp->block_offset >= fp->block_length) {
		if (bgzf_read_block(fp) != 0) return -2; /* error */
		if (fp->block_length == 0) return -1; /* end-of-file */
	}
	c = ((unsigned char*)fp->uncompressed_block)[fp->block_offset++];
    if (fp->block_offset == fp->block_length) {
        fp->block_address = _bgzf_tell((_bgzf_file_t)fp->fp);
        fp->block_offset = 0;
        fp->block_length = 0;
    }
	return c;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %ecx
cmpl %eax, %ecx
jge 0x37ddb
movq 0x18(%rbx), %rdx
leal 0x1(%rcx), %esi
movl %esi, 0xc(%rbx)
movslq %ecx, %rcx
movzbl (%rdx,%rcx), %ebp
cmpl %eax, %esi
jne 0x37dec
movq 0x30(%rbx), %rdi
callq 0x5560
movq %rax, 0x10(%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x37dec
movq %rbx, %rdi
callq 0x376fc
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
testl %eax, %eax
je 0x37df5
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x37e01
movl 0xc(%rbx), %ecx
jmp 0x37daf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x37dec
// File: /workspace/github_cpp_makefile_star2_O3/auton1[P]viterbi/bgzf.c
// Function: bgzf_read_init
static BGZF *bgzf_read_init()
{
	BGZF *fp;
	fp = (BGZF*)calloc(1, sizeof(BGZF));
	fp->is_write = 0;
	fp->uncompressed_block = malloc(BGZF_MAX_BLOCK_SIZE);
	fp->compressed_block = malloc(BGZF_MAX_BLOCK_SIZE);
#ifdef BGZF_CACHE
	fp->cache = kh_init(cache);
#endif
	return fp;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x38, %esi
callq 0x52a0
movq %rax, %rbx
movl $0x10000, %edi          # imm = 0x10000
callq 0x55c0
movq %rax, 0x18(%rbx)
movl $0x10000, %edi          # imm = 0x10000
callq 0x55c0
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/main.cpp
// Function: main
int main(int argc, char* argv[])
{
	if (argc != 2)
	{
		std::cerr << "Usage: ./test seed" << std::endl;
		std::cerr << "Provide a seed please" << std::endl;
		return 1;
	}

	g_seed = atoi(argv[1]);

	section_wrapper(test_containers, "containers");
	section_wrapper(test_others, "others");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpl $0x2, %edi
jne 0x2ed8
movq 0x8(%rsi), %rdi
callq 0x22d0
movl %eax, 0x31391(%rip)     # 0x341e0
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x231cf(%rip), %rsi     # 0x2602d
leaq 0x231d2(%rip), %rdx     # 0x26037
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq 0x77c8(%rip), %rdi      # 0xa640
movq %rbx, %rsi
callq 0x25bb8
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x2e8e
callq 0x21b0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x2319b(%rip), %rsi     # 0x26038
leaq 0x2319a(%rip), %rdx     # 0x2603e
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq 0x21fb1(%rip), %rdi     # 0x24e68
movq %rbx, %rsi
callq 0x25bb8
movq -0x30(%rbp), %rdi
xorl %ebx, %ebx
cmpq %r14, %rdi
je 0x2f5a
callq 0x21b0
jmp 0x2f5a
movq 0x31111(%rip), %rbx     # 0x33ff0
leaq 0x2311e(%rip), %rsi     # 0x26004
movl $0x12, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq 0x230f6(%rip), %rsi     # 0x26017
movl $0x15, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movl $0x1, %ebx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0x2f75
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x2f7f
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_allocator.cpp
// Function: test_set_allocator_cplusplus()
void
test_set_allocator_cplusplus()
{
	ft::set<int> set;
	int* p;
	unsigned int i;

	// allocate an array with space for 5 elements using set's allocator:
	p = set.get_allocator().allocate(5);

	// construct values in-place on the array:
	for (i = 0; i < 5; i++)
		set.get_allocator().construct(&p[i], i);

	std::cout << "The allocated array contains:";
	for (i = 0; i < 5; i++)
		std::cout << ' ' << p[i];
	std::cout << std::endl;

	// destroy and deallocate:
	for (i = 0; i < 5; i++)
		set.get_allocator().destroy(&p[i]);
	set.get_allocator().deallocate(p, 5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movl $0x14, %edi
callq 0x2200
movq %rax, %rbx
xorl %eax, %eax
movl %eax, (%rbx,%rax,4)
incq %rax
cmpq $0x5, %rax
jne 0x3062
movq 0x30f5b(%rip), %rdi     # 0x33fd0
leaq 0x22fed(%rip), %rsi     # 0x26069
movl $0x1d, %edx
callq 0x2230
xorl %r12d, %r12d
movq 0x30f40(%rip), %r14     # 0x33fd0
leaq -0x21(%rbp), %r15
movb $0x20, -0x21(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movl (%rbx,%r12,4), %esi
movq %rax, %rdi
callq 0x2330
incq %r12
cmpq $0x5, %r12
jne 0x3094
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x30ef5(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
leaq -0x58(%rbp), %rdi
callq 0x3602
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x310a
jmp 0x310a
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_allocator.cpp
// Function: test_set_allocator_custom_allocator()
void
test_set_allocator_custom_allocator()
{
	ft::set<int, ft::less<int>, custom_allocator<int> > set;

	set.insert(-42);
	set.insert(0);
	set.insert(42);

	print_set_info(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
leaq -0x38(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0xc(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0x371c
leaq -0xc(%rbp), %rsi
movl $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x371c
leaq -0xc(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x371c
leaq -0x40(%rbp), %rdi
callq 0x33c2
leaq -0x40(%rbp), %rdi
callq 0x365a
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x319b
jmp 0x319b
jmp 0x319b
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x365a
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_allocator.cpp
// Function: test_set_allocator_strings_custom_allocator()
void
test_set_allocator_strings_custom_allocator()
{
	ft::set<std::string, ft::less<std::string>, custom_allocator<std::string> > set;

	set.insert("hello");
	set.insert("world");
	set.insert("! :)");

	print_set_info(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq -0x58(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x22ea2(%rip), %rsi     # 0x26087
leaq 0x22ea0(%rip), %rdx     # 0x2608c
leaq -0x30(%rbp), %rdi
callq 0x2f88
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3838
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3210
callq 0x21b0
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x235d0(%rip), %rsi     # 0x267ee
leaq 0x235ce(%rip), %rdx     # 0x267f3
callq 0x2f88
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3838
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3245
callq 0x21b0
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x22e3a(%rip), %rsi     # 0x2608d
leaq 0x22e37(%rip), %rdx     # 0x26091
callq 0x2f88
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3838
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x327a
callq 0x21b0
leaq -0x60(%rbp), %rdi
callq 0x34d9
leaq -0x60(%rbp), %rdi
callq 0x36b2
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x32b2
jmp 0x329f
jmp 0x32b2
jmp 0x329f
jmp 0x32b2
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x32b5
callq 0x21b0
jmp 0x32b5
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x36b2
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/utils/print_containers_info.hpp
// Function: void print_set_info<std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, custom_allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, custom_allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void
print_set_info(Set const& set)
{
	std::cout << "Size: " << set.size() << std::endl;

	if (set.empty())
		std::cout << "Set is empty" << std::endl;
	else
	{
		std::cout << "Values: ";
		for (typename Set::const_iterator it = set.begin(); it != set.end(); it++)
			std::cout << *it << " ";
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x30adf(%rip), %rbx     # 0x33fd0
leaq 0x22bb3(%rip), %rsi     # 0x260ab
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2230
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
cmpq $0x0, 0x28(%r14)
je 0x35a7
movq 0x30a87(%rip), %rdi     # 0x33fd0
leaq 0x22b6f(%rip), %rsi     # 0x260bf
movl $0x8, %edx
callq 0x2230
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x35bf
movq 0x30a62(%rip), %r12     # 0x33fd0
leaq 0x23d95(%rip), %r13     # 0x2730a
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %r12, %rdi
callq 0x2230
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2230
movq %r15, %rdi
callq 0x2240
movq %rax, %r15
cmpq %r14, %rax
jne 0x3575
jmp 0x35bf
movq 0x30a22(%rip), %rdi     # 0x33fd0
leaq 0x22afd(%rip), %rsi     # 0x260b2
movl $0xc, %edx
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_constructors.cpp
// Function: test_set_constructors_range()
void
test_set_constructors_range()
{
	ft::set<int> set;
	ft::set<int> range1(set.begin(), set.end());

	print_set_info(set);
	print_set_info(range1);

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		set.insert(rand() % 10000 - 10000 / 2);

	ft::set<int> range2(set.begin(), set.end());

	print_set_info(set);
	print_set_info(range2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
leaq -0x48(%rbp), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0xb0(%rbp), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x4158
leaq -0x50(%rbp), %rdi
callq 0x419b
leaq -0xb0(%rbp), %rdi
callq 0x419b
leaq 0x30769(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0x64, %r12d
leaq -0x50(%rbp), %r14
leaq -0x80(%rbp), %r15
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
addl %ecx, %eax
addl $0xffffec78, %eax       # imm = 0xFFFFEC78
movl %eax, -0x80(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e54
decl %r12d
jne 0x3a8c
movq -0x38(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rbx, %rdx
callq 0x4158
leaq -0x50(%rbp), %rdi
callq 0x419b
leaq -0x80(%rbp), %rdi
callq 0x419b
leaq -0x80(%rbp), %rdi
callq 0x3602
leaq -0xb0(%rbp), %rdi
callq 0x3602
leaq -0x50(%rbp), %rdi
callq 0x3602
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b30
movq %rax, %rbx
jmp 0x3b3f
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3602
jmp 0x3b33
jmp 0x3b30
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x3602
leaq -0x50(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_constructors.cpp
// Function: test_set_constructors_copy_int()
void
test_set_constructors_copy_int()
{
	ft::set<int> set;

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		set.insert(rand() % 10000 - 10000 / 2);

	{
		ft::set<int> cpy1 = set;
		ft::set<int> cpy2(cpy1);

		print_set_info(set);
		print_set_info(cpy1);
		print_set_info(cpy2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
leaq -0x70(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x3065d(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0x64, %r15d
leaq -0x78(%rbp), %rbx
leaq -0x48(%rbp), %r14
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
addl %ecx, %eax
addl $0xffffec78, %eax       # imm = 0xFFFFEC78
movl %eax, -0x48(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e54
decl %r15d
jne 0x3b98
leaq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x4698
leaq -0xa8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4698
leaq -0x78(%rbp), %rdi
callq 0x419b
leaq -0x48(%rbp), %rdi
callq 0x419b
leaq -0xa8(%rbp), %rdi
callq 0x419b
leaq -0xa8(%rbp), %rdi
callq 0x3602
leaq -0x48(%rbp), %rdi
callq 0x3602
leaq -0x78(%rbp), %rdi
callq 0x3602
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3c52
jmp 0x3c5d
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x3602
leaq -0x48(%rbp), %rdi
callq 0x3602
jmp 0x3c60
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_constructors.cpp
// Function: test_set_constructors_copy_string()
void
test_set_constructors_copy_string()
{
	ft::set<std::string> set;

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		set.insert(ft_itoa(rand() % 10000 - 10000 / 2));

	{
		ft::set<std::string> cpy1 = set;
		ft::set<std::string> cpy2(set);

		print_set_info(set);
		print_set_info(cpy1);
		print_set_info(cpy2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
leaq -0x78(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x3053a(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0x64, %r12d
leaq -0x40(%rbp), %r15
leaq -0x50(%rbp), %rbx
leaq -0x80(%rbp), %r14
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
leal (%rax,%rcx), %esi
addl $0xffffec78, %esi       # imm = 0xFFFFEC78
movq %rbx, %rdi
callq 0x42b2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4f0c
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x3d0c
callq 0x21b0
decl %r12d
jne 0x3cbf
leaq -0x50(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x483c
leaq -0xb0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x483c
leaq -0x80(%rbp), %rdi
callq 0x434b
leaq -0x50(%rbp), %rdi
callq 0x434b
leaq -0xb0(%rbp), %rdi
callq 0x434b
leaq -0xb0(%rbp), %rdi
callq 0x4b46
leaq -0x50(%rbp), %rdi
callq 0x4b46
leaq -0x80(%rbp), %rdi
callq 0x4b46
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3d90
jmp 0x3d9b
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x4b46
leaq -0x50(%rbp), %rdi
callq 0x4b46
jmp 0x3db1
movq %rax, %rbx
jmp 0x3db1
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x3db1
callq 0x21b0
leaq -0x80(%rbp), %rdi
callq 0x4b46
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_constructors.cpp
// Function: test_set_constructors_custom_compare_int()
void
test_set_constructors_custom_compare_int()
{
	ft::set<int, greater<int> > set;

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		set.insert(rand() % 10000 - 10000 / 2);

	print_set_info(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x303ee(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0x64, %r15d
leaq -0x50(%rbp), %rbx
leaq -0x1c(%rbp), %r14
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
addl %ecx, %eax
addl $0xffffec78, %eax       # imm = 0xFFFFEC78
movl %eax, -0x1c(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x50bc
decl %r15d
jne 0x3e07
leaq -0x50(%rbp), %rdi
callq 0x4466
leaq -0x50(%rbp), %rdi
callq 0x4b5e
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e63
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4b5e
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_constructors.cpp
// Function: test_set_constructors_custom_compare_string()
void
test_set_constructors_custom_compare_string()
{
	ft::set<std::string, greater<std::string> > set;

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		set.insert(ft_itoa(rand() % 10000 - 10000 / 2));

	print_set_info(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
leaq -0x68(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x30337(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0x64, %r12d
leaq -0x30(%rbp), %r15
leaq -0x40(%rbp), %rbx
leaq -0x70(%rbp), %r14
callq 0x2070
cltq
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
negl %ecx
leal (%rax,%rcx), %esi
addl $0xffffec78, %esi       # imm = 0xFFFFEC78
movq %rbx, %rdi
callq 0x42b2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51d8
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3f0f
callq 0x21b0
decl %r12d
jne 0x3ec2
leaq -0x70(%rbp), %rdi
callq 0x457d
leaq -0x70(%rbp), %rdi
callq 0x4bb6
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f35
movq %rax, %rbx
jmp 0x3f4b
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3f4b
callq 0x21b0
leaq -0x70(%rbp), %rdi
callq 0x4bb6
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_constructors.cpp
// Function: test_set_constructors()
void
test_set_constructors()
{
	test_wrapper(test_set_constructors_empty, "empty");
	test_wrapper(test_set_constructors_range, "range");
	test_wrapper(test_set_constructors_copy_int, "copy int");
	test_wrapper(test_set_constructors_copy_string, "copy string");
	test_wrapper(test_set_constructors_custom_compare_int, "custom_compare_int");
	test_wrapper(test_set_constructors_custom_compare_string, "custom_compare_string");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
leaq -0xc0(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x22df5(%rip), %rsi     # 0x26d71
leaq 0x22df3(%rip), %rdx     # 0x26d76
leaq -0xd0(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x5b1(%rip), %rdi      # 0x39e8
movq %rbx, %rsi
callq 0x25dae
movq -0xd0(%rbp), %rdi
cmpq %r14, %rdi
je 0x3fb2
callq 0x21b0
leaq -0xa0(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x23270(%rip), %rsi     # 0x27234
leaq 0x2326e(%rip), %rdx     # 0x27239
leaq -0xb0(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x5c6(%rip), %rdi      # 0x3a1b
movq %rbx, %rsi
callq 0x25dae
movq -0xb0(%rbp), %rdi
cmpq %r14, %rdi
je 0x3ffa
callq 0x21b0
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x220d7(%rip), %rsi     # 0x260e0
leaq 0x220d8(%rip), %rdx     # 0x260e8
leaq -0x90(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x4d6(%rip), %rdi      # 0x3b50
movq %rbx, %rsi
callq 0x25dae
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x403f
callq 0x21b0
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x2209b(%rip), %rsi     # 0x260e9
leaq 0x2209f(%rip), %rdx     # 0x260f4
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x3f7(%rip), %rdi      # 0x3c71
movq %rbx, %rsi
callq 0x25dae
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x407e
callq 0x21b0
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x22068(%rip), %rsi     # 0x260f5
leaq 0x22073(%rip), %rdx     # 0x26107
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x2e5(%rip), %rdi      # 0x3dc2
movq %rbx, %rsi
callq 0x25dae
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x40bd
callq 0x21b0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x2203c(%rip), %rsi     # 0x26108
leaq 0x2204a(%rip), %rdx     # 0x2611d
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f88
leaq -0x26f(%rip), %rdi      # 0x3e77
movq %rbx, %rsi
callq 0x25dae
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x40fc
callq 0x21b0
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0x4145
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0x4145
movq %rax, %rbx
movq -0x70(%rbp), %rdi
jmp 0x4145
movq %rax, %rbx
movq -0x90(%rbp), %rdi
jmp 0x4145
movq %rax, %rbx
movq -0xb0(%rbp), %rdi
jmp 0x4145
movq %rax, %rbx
movq -0xd0(%rbp), %rdi
cmpq %r14, %rdi
je 0x414f
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_modifiers.cpp
// Function: test_set_modifiers_insert_with_hint()
void
test_set_modifiers_insert_with_hint()
{
	ft::set<int> set;
	ft::set<int>::iterator hint;
	ft::set<int>::iterator ret;

	set.insert(10);
	set.insert(100);
	set.insert(60);

	hint = set.find(10);
	ret = set.insert(hint, 42);
	std::cout << "Return: " << *ret << std::endl;
	print_set_info(set);

	ret = set.insert(set.begin(), 0);
	std::cout << "Return: " << *ret << std::endl;
	print_set_info(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x48(%rbp), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0x18(%rbp), %rsi
movl $0xa, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x4e54
leaq -0x18(%rbp), %rsi
movl $0x64, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x4e54
leaq -0x18(%rbp), %rsi
movl $0x3c, (%rsi)
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x4e54
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x5a2e
movq %rbx, %rdx
movq %rdx, %rax
movq %rdi, %rcx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl $0xa, %esi
setl %dil
movq %rcx, %rdx
cmovlq %rax, %rdx
movq 0x10(%rcx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x59f7
cmpq %rbx, %rdx
je 0x5a2e
cmpl $0xa, %esi
cmovlq %rax, %rcx
cmpl $0xb, 0x20(%rcx)
cmovlq %rdx, %rbx
leaq -0x1c(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x18(%rbp), %rcx
movq %r14, (%rcx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7206
movq %rax, %rbx
movq 0x2e57c(%rip), %rdi     # 0x33fd0
leaq 0x206c3(%rip), %rsi     # 0x2611e
movl $0x8, %edx
callq 0x2230
movl 0x20(%rbx), %esi
movq 0x2e561(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x419b
movq -0x38(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
movl $0x0, (%rdx)
leaq -0x18(%rbp), %rcx
movq %rbx, (%rcx)
movq %rbx, %rdi
callq 0x7206
movq %rax, %rbx
movq 0x2e4ff(%rip), %rdi     # 0x33fd0
leaq 0x20646(%rip), %rsi     # 0x2611e
movl $0x8, %edx
callq 0x2230
movl 0x20(%rbx), %esi
movq 0x2e4e4(%rip), %rdi     # 0x33fd0
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x50(%rbp), %rdi
callq 0x419b
leaq -0x50(%rbp), %rdi
callq 0x3602
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x5b40
jmp 0x5b40
jmp 0x5b40
jmp 0x5b40
jmp 0x5b40
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_modifiers.cpp
// Function: test_set_modifiers_insert_range()
void
test_set_modifiers_insert_range()
{
	ft::set<int> set1;
	ft::set<int> set2;

	set2.insert(set1.begin(), set1.end());

	print_set_info(set1);
	print_set_info(set2);

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		set1.insert(rand() % 1000 - 1000 / 2);
	set2.insert(set1.begin(), set1.end());

	print_set_info(set1);
	print_set_info(set2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
leaq -0x80(%rbp), %rbx
xorl %eax, %eax
movl %eax, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
leaq -0x50(%rbp), %rcx
movl %eax, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x4c20
leaq -0x88(%rbp), %rdi
callq 0x419b
leaq -0x58(%rbp), %rdi
callq 0x419b
leaq 0x2e624(%rip), %rax     # 0x341e0
movl (%rax), %edi
callq 0x21d0
movl $0x64, %r12d
leaq -0x88(%rbp), %r14
leaq -0x24(%rbp), %r15
callq 0x2070
cltq
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
negl %ecx
addl %ecx, %eax
addl $0xfffffe0c, %eax       # imm = 0xFFFFFE0C
movl %eax, -0x24(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e54
decl %r12d
jne 0x5bd4
movq -0x70(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rbx, %rdx
callq 0x4c20
leaq -0x88(%rbp), %rdi
callq 0x419b
leaq -0x58(%rbp), %rdi
callq 0x419b
leaq -0x58(%rbp), %rdi
callq 0x3602
leaq -0x88(%rbp), %rdi
callq 0x3602
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c5a
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3602
leaq -0x88(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_modifiers.cpp
// Function: test_set_modifiers_insert_iterators_validity()
void
test_set_modifiers_insert_iterators_validity()
{
	ft::set<int> set;
	ft::set<int>::iterator it;

	set.insert(42);
	it = set.find(42);

	for (int i = 0; i < 20; i++)
		set.insert(i);

	print_set_info(set);

	if (it == set.find(42))
		std::cout << "correct" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %r15
movl $0x0, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rax, 0x20(%r15)
leaq -0x24(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x58(%rbp), %rdi
callq 0x4e54
movq -0x48(%rbp), %rdi
movq %r15, %r12
testq %rdi, %rdi
je 0x5d05
movq %r15, %rdx
movq %rdx, %rax
movq %rdi, %rcx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl $0x2a, %esi
setl %dil
movq %rcx, %rdx
cmovlq %rax, %rdx
movq 0x10(%rcx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x5cc8
movq %r15, %r12
cmpq %r15, %rdx
je 0x5d05
cmpl $0x2a, %esi
cmovlq %rax, %rcx
cmpl $0x2b, 0x20(%rcx)
cmovgeq %r15, %rdx
movq %rdx, %r12
leaq -0x24(%rbp), %rbx
movl $0x0, (%rbx)
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x724a
movl -0x24(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x13, %eax
jl 0x5d13
leaq -0x58(%rbp), %rdi
callq 0x419b
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x5d78
movq %r15, %rdx
movq %rdx, %rax
movq %rdi, %rcx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl $0x2a, %esi
setl %dil
movq %rcx, %rdx
cmovlq %rax, %rdx
movq 0x10(%rcx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x5d41
cmpq %r15, %rdx
je 0x5d78
cmpl $0x2a, %esi
cmovlq %rax, %rcx
cmpl $0x2b, 0x20(%rcx)
cmovlq %rdx, %r15
cmpq %r15, %r12
jne 0x5dc3
movq 0x2e24c(%rip), %rbx     # 0x33fd0
leaq 0x203a4(%rip), %rsi     # 0x2612f
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2e21a(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x58(%rbp), %rdi
callq 0x3602
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ddd
jmp 0x5ddd
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_modifiers.cpp
// Function: test_set_modifiers_insert_cplusplus()
void
test_set_modifiers_insert_cplusplus()
{
	ft::set<int> myset;
	ft::set<int>::iterator it;
	ft::pair<ft::set<int>::iterator, bool> ret;

	for (int i = 1; i <= 5; ++i)
		myset.insert(i * 10);

	ret = myset.insert(20);

	if (ret.second == false)
		it = ret.first;

	myset.insert(it,25);
	myset.insert(it,24);
	myset.insert(it,26);

	int myints[] = {5, 10, 15};
	myset.insert(myints, myints + 3);

	std::cout << "myset contains:";
	for (it = myset.begin(); it != myset.end(); ++it)
		std::cout << ' ' << *it;
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq -0x68(%rbp), %rbx
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movl $0xa, %r12d
leaq -0x70(%rbp), %r14
leaq -0x38(%rbp), %r15
movl %r12d, -0x38(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e54
addl $0xa, %r12d
cmpl $0x3c, %r12d
jne 0x5e2c
leaq -0x38(%rbp), %rsi
movl $0x14, (%rsi)
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x4e54
xorl %r15d, %r15d
testb %dl, %dl
cmoveq %rax, %r15
leaq -0x40(%rbp), %rdx
movl $0x19, (%rdx)
leaq -0x38(%rbp), %rcx
movq %r14, (%rcx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7206
leaq -0x40(%rbp), %rdx
movl $0x18, (%rdx)
leaq -0x38(%rbp), %rcx
movq %r14, (%rcx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7206
leaq -0x40(%rbp), %rdx
movl $0x1a, (%rdx)
leaq -0x38(%rbp), %rcx
movq %r14, (%rcx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7206
movabsq $0xa00000005, %rax      # imm = 0xA00000005
movq %rax, -0x38(%rbp)
movl $0xf, -0x30(%rbp)
leaq -0x40(%rbp), %r15
movq %r14, (%r15)
xorl %r12d, %r12d
leaq (%r12,%rbp), %rdx
addq $-0x38, %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x728a
addq $0x4, %r12
cmpq $0xc, %r12
jne 0x5ed7
movq 0x2e0d2(%rip), %r14     # 0x33fd0
leaq 0x20232(%rip), %rsi     # 0x26137
movl $0xf, %edx
movq %r14, %rdi
callq 0x2230
movq -0x58(%rbp), %r15
cmpq %rbx, %r15
je 0x5f56
movq 0x2e0ae(%rip), %r12     # 0x33fd0
leaq -0x40(%rbp), %r13
movb $0x20, -0x40(%rbp)
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2230
movl 0x20(%r15), %esi
movq %rax, %rdi
callq 0x2330
movq %r15, %rdi
callq 0x2240
movq %rax, %r15
cmpq %rbx, %rax
jne 0x5f26
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x2e05c(%rip), %rdi     # 0x33fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq -0x70(%rbp), %rdi
callq 0x3602
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5fa7
jmp 0x5fa7
jmp 0x5fa7
jmp 0x5fa7
jmp 0x5fa7
jmp 0x5fa7
jmp 0x5fa7
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x3602
movq %rbx, %rdi
callq 0x2340