LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x2c7cd
movq %rdi, %r14
testb $0x3, 0x2(%rdi)
jne 0x2c800
movq %rdx, %rbp
movq %rsi, %r12
movl 0xc(%r14), %eax
xorl %ebx, %ebx
movq %rbp, %r15
movl 0x8(%r14), %ecx
subq %rbx, %r15
jbe 0x2c7d1
subl %eax, %ecx
jg 0x2c79e
movq %r14, %rdi
callq 0x2c5cc
testl %eax, %eax
jne 0x2c7eb
movl 0x8(%r14), %edx
movl 0xc(%r14), %eax
movl %edx, %ecx
subl %eax, %ecx
jle 0x2c7d3
movl %ecx, %r13d
cmpq %r13, %r15
cmovbq %r15, %r13
movslq %eax, %rsi
addq 0x18(%r14), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x53b0
movl 0xc(%r14), %eax
addl %r13d, %eax
movl %eax, 0xc(%r14)
addq %r13, %r12
addq %r13, %rbx
jmp 0x2c774
xorl %ebx, %ebx
jmp 0x2c7ee
movl %ecx, %edx
cmpl %edx, %eax
jne 0x2c7ee
movq 0x30(%r14), %rdi
callq 0x5590
movq %rax, 0x10(%r14)
andq $0x0, 0x8(%r14)
jmp 0x2c7ee
pushq $-0x1
popq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3427(%rip), %rdi      # 0x2fc2e
leaq 0x33c7(%rip), %rsi      # 0x2fbd5
leaq 0x342b(%rip), %rcx      # 0x2fc40
movl $0x162, %edx            # imm = 0x162
callq 0x52a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testb $0x3, 0x2(%rdi)
je 0x2c86c
movq %rdi, %r14
pushq $-0x1
popq %rbx
pushq $0x1
popq %r15
movl 0xc(%r14), %esi
testl %esi, %esi
jle 0x2c86c
movq %r14, %rdi
callq 0x2c882
testl %eax, %eax
js 0x2c874
movl %eax, %r12d
movq 0x20(%r14), %rdi
movq 0x30(%r14), %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x58c0
cmpq %r12, %rax
jne 0x2c870
addq %r12, 0x10(%r14)
jmp 0x2c837
xorl %ebx, %ebx
jmp 0x2c874
orb $0x4, (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc05(%rip), %rax       # 0x2d4cf
pushq $-0xf
popq %rcx
pushq $0x8
popq %rdx
movl %edx, %r8d
xorl %r9d, %r9d
pushq $0x70
pushq %rax
callq 0x5060
popq %rcx
popq %rdx
testl %eax, %eax
jne 0x2c900
movq %rsp, %rdi
pushq $0x4
popq %rsi
callq 0x51c0
cmpl $0x1, %eax
jne 0x2c900
movq %rsp, %rdi
callq 0x5240
testl %eax, %eax
je 0x2c915
orb $0x1, (%rbx)
pushq $-0x1
popq %rbp
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 0x33ad(%rip), %xmm0     # 0x2fcd0
movups %xmm0, (%r12)
addl $0x19, %eax
movw %ax, 0x10(%r12)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5320
movq %rax, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x5320
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)
andl $0x0, 0xc(%rbx)
jmp 0x2c906
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testb $0x3, 0x2(%rdi)
je 0x2ca22
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movslq %ebp, %rax
movq %rbx, %rcx
subq %rax, %rcx
jbe 0x2ca19
movslq 0xc(%r15), %rdi
movl $0xff00, %eax           # imm = 0xFF00
subq %rdi, %rax
cmpq %rax, %rcx
cmoval %eax, %ecx
addq 0x18(%r15), %rdi
movslq %ecx, %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0x53b0
movl 0xc(%r15), %eax
addl %r12d, %eax
movl %eax, 0xc(%r15)
addq %r12, %r14
addl %r12d, %ebp
cmpl $0xff00, %eax           # imm = 0xFF00
jne 0x2c9c3
movq %r15, %rdi
callq 0x2c81f
testl %eax, %eax
je 0x2c9c3
movslq %ebp, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3241(%rip), %rdi      # 0x2fc6a
leaq 0x31a5(%rip), %rsi      # 0x2fbd5
leaq 0x3240(%rip), %rcx      # 0x2fc77
movl $0x239, %edx            # imm = 0x239
callq 0x52a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0x1
popq %rbp
testq %rdi, %rdi
je 0x2cabf
movq %rdi, %rbx
testb $0x3, 0x2(%rdi)
je 0x2ca96
movq %rbx, %rdi
callq 0x2c81f
testl %eax, %eax
jne 0x2cabf
orl $0xfff00000, (%rbx)     # imm = 0xFFF00000
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2c882
movslq %eax, %rdx
movq 0x20(%rbx), %rdi
movq 0x30(%rbx), %rcx
pushq $0x1
popq %rsi
callq 0x58c0
movq 0x30(%rbx), %rdi
callq 0x5540
testl %eax, %eax
je 0x2ca96
orb $0x4, (%rbx)
jmp 0x2cabf
movq 0x30(%rbx), %rdi
callq 0x5490
testl %eax, %eax
jne 0x2cabf
movq 0x18(%rbx), %rdi
callq 0x5560
movq 0x20(%rbx), %rdi
callq 0x5560
movq %rbx, %rdi
callq 0x5560
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x5590
movq %rax, %r14
movq 0x30(%rbx), %rdi
pushq $-0x1c
popq %rsi
pushq $0x2
popq %rdx
callq 0x5230
testl %eax, %eax
js 0x2cb42
movq 0x30(%rbx), %rcx
movq %rsp, %r15
pushq $0x1
popq %rsi
pushq $0x1c
popq %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x5680
movq 0x30(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5230
leaq 0x3184(%rip), %rdi      # 0x2fcb0
movq %r15, %rsi
movq %r12, %rdx
callq 0x54b0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0x2cb44
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2cb70
orl $0x8, %eax
movl %eax, (%rbx)
pushq $-0x1
popq %rax
jmp 0x2cb9d
movq %rsi, %r14
movq %rsi, %r15
sarq $0x10, %r15
movq 0x30(%rbx), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x5230
testl %eax, %eax
js 0x2cba3
andl $0x0, 0x8(%rbx)
movzwl %r14w, %eax
movq %r15, 0x10(%rbx)
movl %eax, 0xc(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
orb $0x4, (%rbx)
jmp 0x2cb6b
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf76(%rip), %rsi       # 0x2db2e
callq 0x5550
xorl %ebx, %ebx
testq %rax, %rax
je 0x2cc04
movq %rax, %r14
movq %rsp, %rdi
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
movq %rax, %rcx
callq 0x5680
movq %rax, %r15
movq %r14, %rdi
callq 0x5490
cmpl $0x10, %r15d
jne 0x2cc04
movdqa (%rsp), %xmm0
pcmpeqb 0x2f9a(%rip), %xmm0     # 0x2fb90
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_O2/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 0x2cc49
movq 0x18(%rbx), %rdx
leal 0x1(%rcx), %esi
movl %esi, 0xc(%rbx)
movslq %ecx, %rcx
movzbl (%rdx,%rcx), %ebp
cmpl %eax, %esi
jne 0x2cc58
movq 0x30(%rbx), %rdi
callq 0x5590
movq %rax, 0x10(%rbx)
andq $0x0, 0x8(%rbx)
jmp 0x2cc58
movq %rbx, %rdi
callq 0x2c5cc
testl %eax, %eax
je 0x2cc61
pushq $-0x2
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x2cc6d
movl 0xc(%rbx), %ecx
jmp 0x2cc20
pushq $-0x1
jmp 0x2cc57
// File: /workspace/github_cpp_makefile_star2_O2/auton1[P]viterbi/bgzf.c
// Function: bgzf_getline
int bgzf_getline(BGZF *fp, int delim, kstring_t *str)
{
	int l, state = 0;
	unsigned char *buf = (unsigned char*)fp->uncompressed_block;
	str->l = 0;
	do {
		if (fp->block_offset >= fp->block_length) {
			if (bgzf_read_block(fp) != 0) { state = -2; break; }
			if (fp->block_length == 0) { state = -1; break; }
		}
		for (l = fp->block_offset; l < fp->block_length && buf[l] != delim; ++l);
		if (l < fp->block_length) state = 1;
		l -= fp->block_offset;
		if (str->l + l + 1 >= str->m) {
			str->m = str->l + l + 2;
			kroundup32(str->m);
			str->s = (char*)realloc(str->s, str->m);
		}
		memcpy(str->s + str->l, buf + fp->block_offset, l);
		str->l += l;
		fp->block_offset += l + 1;
		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;
		} 
	} while (state == 0);
	if (str->l == 0 && state < 0) return state;
	str->s[str->l] = 0;
	return str->l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %r15
movq 0x18(%rdi), %r13
andq $0x0, (%rdx)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
cmpl %ecx, %eax
jl 0x2ccc6
movq %r15, %rdi
callq 0x2c5cc
testl %eax, %eax
jne 0x2cdbf
movl 0x8(%r15), %ecx
testl %ecx, %ecx
movq 0x8(%rsp), %rdx
je 0x2cdc8
movl 0xc(%r15), %eax
movslq %eax, %rsi
movslq %ecx, %rbp
cmpl %ebp, %esi
movl %ebp, %ecx
cmovgl %esi, %ecx
movq %rsi, %rbx
cmpq %rbp, %rbx
jge 0x2cced
movzbl (%r13,%rbx), %edi
cmpl %r14d, %edi
je 0x2cceb
incq %rbx
jmp 0x2ccd6
movl %ebx, %ecx
subl %eax, %ecx
movq (%rdx), %rdi
movq 0x10(%rdx), %rax
movslq %ecx, %r8
leaq (%r8,%rdi), %rcx
incq %rcx
cmpq 0x8(%rdx), %rcx
jae 0x2cd0d
movq 0x10(%rsp), %r15
jmp 0x2cd68
movq %rcx, %rsi
shrq %rsi
orq %rcx, %rsi
movq %rsi, %rcx
shrq $0x2, %rcx
orq %rsi, %rcx
movq %rcx, %rsi
shrq $0x4, %rsi
orq %rcx, %rsi
movq %rsi, %rcx
shrq $0x8, %rcx
orq %rsi, %rcx
movq %rcx, %rsi
shrq $0x10, %rsi
orq %rcx, %rsi
incq %rsi
movq %rsi, 0x8(%rdx)
movq %rax, %rdi
movq %rdx, %r12
movq %r8, %r15
callq 0x5750
movq %r15, %r8
movq %rax, 0x10(%r12)
movq (%r12), %rdi
movq 0x10(%rsp), %r15
movslq 0xc(%r15), %rsi
addq %rax, %rdi
addq %r13, %rsi
movq %r8, %rdx
movq %r8, %r12
callq 0x53b0
movq 0x8(%rsp), %rdx
addq %r12, (%rdx)
movl 0x8(%r15), %ecx
movl 0xc(%r15), %eax
addl %r12d, %eax
incl %eax
movl %eax, 0xc(%r15)
cmpl %ecx, %eax
jl 0x2cdb1
movq 0x30(%r15), %rdi
callq 0x5590
movq 0x8(%rsp), %rdx
movq %rax, 0x10(%r15)
andq $0x0, 0x8(%r15)
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rbp, %rbx
jge 0x2cc9d
movq (%rdx), %rsi
jmp 0x2cdd3
movq 0x8(%rsp), %rdx
pushq $-0x2
jmp 0x2cdca
pushq $-0x1
popq %rax
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x2cddd
movq 0x10(%rdx), %rcx
movb $0x0, (%rcx,%rsi)
movl (%rdx), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0x52c0
movq %rax, %rbx
movl $0x10000, %edi          # imm = 0x10000
callq 0x5600
movq %rax, 0x18(%rbx)
movl $0x10000, %edi          # imm = 0x10000
callq 0x5600
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
cmpl $0x2, %edi
jne 0x3d37
movq 0x8(%rsi), %rdi
callq 0x32c0
movl %eax, 0x2e4ff(%rip)     # 0x321d8
leaq 0x1d34d(%rip), %rsi     # 0x2102d
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0x6114(%rip), %rdi      # 0x9e08
leaq -0x50(%rbp), %rsi
callq 0x20b5c
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0x1d32b(%rip), %rsi     # 0x21038
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq 0x1c19b(%rip), %rdi     # 0x1febc
leaq -0x30(%rbp), %rsi
callq 0x20b5c
leaq -0x30(%rbp), %rdi
callq 0x30d0
xorl %eax, %eax
jmp 0x3d6f
movq 0x2e2b2(%rip), %rbx     # 0x31ff0
leaq 0x1d2bf(%rip), %rsi     # 0x21004
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq 0x1d2bb(%rip), %rsi     # 0x21017
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
pushq $0x1
popq %rax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x3d88
jmp 0x3d8f
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30d0
jmp 0x3d92
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x30, %rsp
leaq -0x48(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
pushq $0x14
popq %rdi
callq 0x31e0
movq %rax, %rbx
xorl %eax, %eax
cmpq $0x5, %rax
je 0x3ddf
movl %eax, (%rbx,%rax,4)
incq %rax
jmp 0x3dd1
movq 0x2e1d2(%rip), %rdi     # 0x31fb8
leaq 0x1d252(%rip), %rsi     # 0x2103f
callq 0x31d0
xorl %r12d, %r12d
movq 0x2e1bc(%rip), %r14     # 0x31fb8
pushq $0x20
popq %r15
cmpq $0x5, %r12
je 0x3e22
movq %r14, %rdi
movl %r15d, %esi
callq 0x3210
movl (%rbx,%r12,4), %esi
movq %rax, %rdi
callq 0x3320
incq %r12
jmp 0x3e00
movq 0x2e18f(%rip), %rdi     # 0x31fb8
callq 0x30e0
movq %rbx, %rdi
callq 0x31a0
leaq -0x50(%rbp), %rdi
callq 0x4202
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e50
jmp 0x3e50
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0xc(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x40(%rbp), %rdi
callq 0x4326
leaq -0xc(%rbp), %rsi
andl $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x4326
leaq -0xc(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x4326
leaq -0x40(%rbp), %rdi
callq 0x409a
leaq -0x40(%rbp), %rdi
callq 0x4258
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x3edb
jmp 0x3edb
jmp 0x3edb
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4258
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x58, %rsp
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x1d145(%rip), %rsi     # 0x2105d
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4464
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq 0x1d87e(%rip), %rsi     # 0x217c0
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4464
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq 0x1d0f7(%rip), %rsi     # 0x21063
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4464
leaq -0x30(%rbp), %rdi
callq 0x30d0
leaq -0x60(%rbp), %rdi
callq 0x4147
leaq -0x60(%rbp), %rdi
callq 0x42ae
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
jmp 0x3fc0
jmp 0x3fb2
jmp 0x3fc0
jmp 0x3fb2
jmp 0x3fc0
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30d0
jmp 0x3fc3
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x42ae
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %r14
movq 0x2de5c(%rip), %rbx     # 0x31fb8
leaq 0x1cf1e(%rip), %rsi     # 0x21081
movq %rbx, %rdi
callq 0x31d0
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
cmpq $0x0, 0x28(%r14)
je 0x41ce
leaq 0x1cf08(%rip), %rsi     # 0x21095
movq %rbx, %rdi
callq 0x31d0
movq 0x18(%r14), %r12
addq $0x8, %r14
leaq 0x1e146(%rip), %r15     # 0x222ea
cmpq %r14, %r12
je 0x41e4
leaq 0x20(%r12), %rsi
movq %rbx, %rdi
callq 0x3190
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
movq %r12, %rdi
callq 0x3200
movq %rax, %r12
jmp 0x41a4
movq 0x2dde3(%rip), %rdi     # 0x31fb8
leaq 0x1ceac(%rip), %rsi     # 0x21088
callq 0x31d0
movq %rax, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq -0x50(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq -0xb8(%rbp), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x4c8a
leaq -0x58(%rbp), %rdi
callq 0x4ccd
leaq -0xb8(%rbp), %rdi
callq 0x4ccd
leaq 0x2db55(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x64
popq %r12
movl $0x2710, %r13d          # imm = 0x2710
leaq -0x58(%rbp), %r14
leaq -0x88(%rbp), %r15
subl $0x1, %r12d
jb 0x46c7
callq 0x3070
cltd
idivl %r13d
addl $0xffffec78, %edx       # imm = 0xFFFFEC78
movl %edx, -0x88(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5824
jmp 0x469f
movq -0x40(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rbx, %rdx
callq 0x4c8a
leaq -0x58(%rbp), %rdi
callq 0x4ccd
leaq -0x88(%rbp), %rdi
callq 0x4ccd
leaq -0x88(%rbp), %rdi
callq 0x4202
leaq -0xb8(%rbp), %rdi
callq 0x4202
leaq -0x58(%rbp), %rdi
callq 0x4202
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x473c
movq %rax, %rbx
jmp 0x474b
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x4202
jmp 0x473f
jmp 0x473c
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x4202
leaq -0x58(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x90, %rsp
leaq -0x78(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x2da4a(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x64
popq %r15
movl $0x2710, %r12d          # imm = 0x2710
leaq -0x80(%rbp), %rbx
leaq -0x50(%rbp), %r14
subl $0x1, %r15d
jb 0x47cc
callq 0x3070
cltd
idivl %r12d
addl $0xffffec78, %edx       # imm = 0xFFFFEC78
movl %edx, -0x50(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5824
jmp 0x47a7
leaq -0x50(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x4ff4
leaq -0xb0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4ff4
leaq -0x80(%rbp), %rdi
callq 0x4ccd
leaq -0x50(%rbp), %rdi
callq 0x4ccd
leaq -0xb0(%rbp), %rdi
callq 0x4ccd
leaq -0xb0(%rbp), %rdi
callq 0x4202
leaq -0x50(%rbp), %rdi
callq 0x4202
leaq -0x80(%rbp), %rdi
callq 0x4202
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x484b
jmp 0x4856
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x4202
leaq -0x50(%rbp), %rdi
callq 0x4202
jmp 0x4859
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x48(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x2d93c(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x64
popq %r15
movl $0x2710, %r12d          # imm = 0x2710
leaq -0x80(%rbp), %rbx
leaq -0x50(%rbp), %r14
subl $0x1, %r15d
jb 0x48e7
callq 0x3070
cltd
idivl %r12d
leal -0x1388(%rdx), %esi
movq %rbx, %rdi
callq 0x4d7a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58f8
movq %rbx, %rdi
callq 0x30d0
jmp 0x48b5
leaq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x523c
leaq -0xb0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x523c
leaq -0x50(%rbp), %rdi
callq 0x4ded
leaq -0x80(%rbp), %rdi
callq 0x4ded
leaq -0xb0(%rbp), %rdi
callq 0x4ded
leaq -0xb0(%rbp), %rdi
callq 0x5518
leaq -0x80(%rbp), %rdi
callq 0x5518
leaq -0x50(%rbp), %rdi
callq 0x5518
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4966
jmp 0x4971
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x5518
leaq -0x80(%rbp), %rdi
callq 0x5518
jmp 0x4982
movq %rax, %rbx
jmp 0x4982
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x30d0
leaq -0x50(%rbp), %rdi
callq 0x5518
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x50(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x2d816(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x64
popq %r15
movl $0x2710, %r12d          # imm = 0x2710
leaq -0x58(%rbp), %rbx
leaq -0x24(%rbp), %r14
subl $0x1, %r15d
jb 0x4a00
callq 0x3070
cltd
idivl %r12d
addl $0xffffec78, %edx       # imm = 0xFFFFEC78
movl %edx, -0x24(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a70
jmp 0x49db
leaq -0x58(%rbp), %rdi
callq 0x4e9a
leaq -0x58(%rbp), %rdi
callq 0x5530
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4a21
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x5530
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x48(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x2d774(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x64
popq %r15
movl $0x2710, %r12d          # imm = 0x2710
leaq -0x70(%rbp), %rbx
leaq -0x50(%rbp), %r14
subl $0x1, %r15d
jb 0x4aaf
callq 0x3070
cltd
idivl %r12d
leal -0x1388(%rdx), %esi
movq %rbx, %rdi
callq 0x4d7a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5bbe
movq %rbx, %rdi
callq 0x30d0
jmp 0x4a7d
leaq -0x50(%rbp), %rdi
callq 0x4f47
leaq -0x50(%rbp), %rdi
callq 0x5586
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ad0
movq %rax, %rbx
jmp 0x4ae1
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq -0x50(%rbp), %rdi
callq 0x5586
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0xc8, %rsp
leaq 0x1d23e(%rip), %rsi     # 0x21d43
leaq -0xd0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x524(%rip), %rdi      # 0x45f8
leaq -0xd0(%rbp), %rsi
callq 0x20ca4
leaq -0xd0(%rbp), %rdi
callq 0x30d0
leaq 0x1d6cd(%rip), %rsi     # 0x22208
leaq -0xb0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x52a(%rip), %rdi      # 0x4628
leaq -0xb0(%rbp), %rsi
callq 0x20ca4
leaq -0xb0(%rbp), %rdi
callq 0x30d0
leaq 0x1c52d(%rip), %rsi     # 0x2109e
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x42c(%rip), %rdi      # 0x475c
leaq -0x90(%rbp), %rsi
callq 0x20ca4
leaq -0x90(%rbp), %rdi
callq 0x30d0
leaq 0x1c500(%rip), %rsi     # 0x210a7
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x351(%rip), %rdi      # 0x486a
leaq -0x70(%rbp), %rsi
callq 0x20ca4
leaq -0x70(%rbp), %rdi
callq 0x30d0
leaq 0x1c4df(%rip), %rsi     # 0x210b3
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x255(%rip), %rdi      # 0x4993
leaq -0x50(%rbp), %rsi
callq 0x20ca4
leaq -0x50(%rbp), %rdi
callq 0x30d0
leaq 0x1c4c5(%rip), %rsi     # 0x210c6
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30a0
leaq -0x1e0(%rip), %rdi      # 0x4a35
leaq -0x30(%rbp), %rsi
callq 0x20ca4
leaq -0x30(%rbp), %rdi
callq 0x30d0
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x4c78
jmp 0x4c7f
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x4c78
jmp 0x4c7f
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x4c78
jmp 0x4c7f
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x4c78
jmp 0x4c7f
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x4c78
jmp 0x4c7f
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x30d0
jmp 0x4c82
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_modifiers.cpp
// Function: test_set_modifiers_insert_single_element_int()
void
test_set_modifiers_insert_single_element_int()
{
	ft::set<int> set;
	ft::pair<ft::set<int>::iterator, bool> ret;

	print_set_info(set);

	ret = set.insert(42);
	std::cout << "Return: " << *ret.first << " " << ret.second << std::endl;

	ret = set.insert(42);
	std::cout << "Return: " << *ret.first << " " << ret.second << std::endl;

	ret = set.insert(60);
	std::cout << "Return: " << *ret.first << " " << ret.second << std::endl;

	ret = set.insert(-42);
	std::cout << "Return: " << *ret.first << " " << ret.second << std::endl;

	print_set_info(set); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x40(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x48(%rbp), %rdi
callq 0x4ccd
leaq -0x14(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0x5824
movq %rax, %r14
movl %edx, %ebx
movq 0x2c208(%rip), %rdi     # 0x31fb8
leaq 0x1b325(%rip), %rsi     # 0x210dc
callq 0x31d0
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x3320
leaq 0x1c51b(%rip), %rsi     # 0x222ea
movq %rax, %rdi
callq 0x31d0
movzbl %bl, %esi
andl $0x1, %esi
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
leaq -0x14(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0x5824
movq %rax, %r14
movl %edx, %ebx
movq 0x2c1ac(%rip), %rdi     # 0x31fb8
leaq 0x1b2c9(%rip), %rsi     # 0x210dc
callq 0x31d0
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x3320
leaq 0x1c4bf(%rip), %rsi     # 0x222ea
movq %rax, %rdi
callq 0x31d0
movzbl %bl, %esi
andl $0x1, %esi
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
leaq -0x14(%rbp), %rsi
movl $0x3c, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0x5824
movq %rax, %r14
movl %edx, %ebx
movq 0x2c150(%rip), %rdi     # 0x31fb8
leaq 0x1b26d(%rip), %rsi     # 0x210dc
callq 0x31d0
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x3320
leaq 0x1c463(%rip), %rsi     # 0x222ea
movq %rax, %rdi
callq 0x31d0
movzbl %bl, %esi
andl $0x1, %esi
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
leaq -0x14(%rbp), %rsi
movl $0xffffffd6, (%rsi)     # imm = 0xFFFFFFD6
leaq -0x48(%rbp), %rdi
callq 0x5824
movq %rax, %r14
movl %edx, %ebx
movq 0x2c0f4(%rip), %rdi     # 0x31fb8
leaq 0x1b211(%rip), %rsi     # 0x210dc
callq 0x31d0
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x3320
leaq 0x1c407(%rip), %rsi     # 0x222ea
movq %rax, %rdi
callq 0x31d0
movzbl %bl, %esi
andl $0x1, %esi
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
callq 0x30e0
leaq -0x48(%rbp), %rdi
callq 0x4ccd
leaq -0x48(%rbp), %rdi
callq 0x4202
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x5f24
jmp 0x5f24
jmp 0x5f24
jmp 0x5f24
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x38, %rsp
leaq -0x38(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0xc(%rbp), %rsi
movl $0xa, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x5824
leaq -0xc(%rbp), %rsi
movl $0x64, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x5824
leaq -0xc(%rbp), %rsi
movl $0x3c, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x5824
leaq -0xc(%rbp), %rsi
movl $0xa, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x7312
leaq -0xc(%rbp), %rdx
movl $0x2a, (%rdx)
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x736a
movq %rax, %rbx
movq 0x2bda2(%rip), %rdi     # 0x31fb8
leaq 0x1aebf(%rip), %rsi     # 0x210dc
callq 0x31d0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
callq 0x4ccd
leaq -0x40(%rbp), %rdi
movq 0x18(%rdi), %rsi
leaq -0xc(%rbp), %rdx
andl $0x0, (%rdx)
callq 0x736a
movq %rax, %rbx
movq 0x2bd5c(%rip), %rdi     # 0x31fb8
leaq 0x1ae79(%rip), %rsi     # 0x210dc
callq 0x31d0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3320
movq %rax, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rdi
callq 0x4ccd
leaq -0x40(%rbp), %rdi
callq 0x4202
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x62a0
jmp 0x62a0
jmp 0x62a0
jmp 0x62a0
jmp 0x62a0
jmp 0x62a0
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq -0x88(%rbp), %rbx
andl $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x55fe
leaq -0x90(%rbp), %rdi
callq 0x4ccd
leaq -0x60(%rbp), %rdi
callq 0x4ccd
leaq 0x2beb3(%rip), %rax     # 0x321d8
movl (%rax), %edi
callq 0x31c0
pushq $0x64
popq %r12
movl $0x3e8, %r13d           # imm = 0x3E8
leaq -0x90(%rbp), %r14
leaq -0x2c(%rbp), %r15
subl $0x1, %r12d
jb 0x6366
callq 0x3070
cltd
idivl %r13d
addl $0xfffffe0c, %edx       # imm = 0xFFFFFE0C
movl %edx, -0x2c(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5824
jmp 0x6341
movq -0x78(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rbx, %rdx
callq 0x55fe
leaq -0x90(%rbp), %rdi
callq 0x4ccd
leaq -0x60(%rbp), %rdi
callq 0x4ccd
leaq -0x60(%rbp), %rdi
callq 0x4202
leaq -0x90(%rbp), %rdi
callq 0x4202
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x63b1
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x4202
leaq -0x90(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x38, %rsp
leaq -0x48(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x1c(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x5824
leaq -0x1c(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x7312
movq %rax, %rbx
xorl %eax, %eax
leaq -0x50(%rbp), %r14
leaq -0x1c(%rbp), %r15
movl %eax, -0x1c(%rbp)
cmpl $0x14, %eax
jge 0x6444
movq %r14, %rdi
movq %r15, %rsi
callq 0x73c8
movl -0x1c(%rbp), %eax
incl %eax
jmp 0x642a
leaq -0x50(%rbp), %rdi
callq 0x4ccd
leaq -0x1c(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x7312
cmpq %rax, %rbx
jne 0x6480
movq 0x2bb4c(%rip), %rdi     # 0x31fb8
leaq 0x1ac7a(%rip), %rsi     # 0x210ed
callq 0x31d0
movq %rax, %rdi
callq 0x30e0
leaq -0x50(%rbp), %rdi
callq 0x4202
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x649c
jmp 0x649c
jmp 0x649c
jmp 0x649c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x58(%rbp), %r12
andl $0x0, (%r12)
andq $0x0, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
andq $0x0, 0x20(%r12)
pushq $0xa
popq %r15
leaq -0x60(%rbp), %rbx
leaq -0x30(%rbp), %r14
cmpl $0x3c, %r15d
je 0x6505
movl %r15d, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5824
addl $0xa, %r15d
jmp 0x64ea
leaq -0x30(%rbp), %rsi
movl $0x14, (%rsi)
leaq -0x60(%rbp), %rdi
callq 0x5824
xorl %ebx, %ebx
testb %dl, %dl
cmoveq %rax, %rbx
leaq -0x30(%rbp), %rdx
movl $0x19, (%rdx)
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x736a
leaq -0x30(%rbp), %rdx
movl $0x18, (%rdx)
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x736a
leaq -0x30(%rbp), %rdx
movl $0x1a, (%rdx)
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x736a
movabsq $0xa00000005, %rax      # imm = 0xA00000005
leaq -0x24(%rbp), %rdx
movq %rax, -0xc(%rdx)
movl $0xf, -0x4(%rdx)
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7408
movq 0x2ba29(%rip), %rdi     # 0x31fb8
leaq 0x1ab5f(%rip), %rsi     # 0x210f5
callq 0x31d0
movq -0x48(%rbp), %r15
movq 0x2ba12(%rip), %rbx     # 0x31fb8
pushq $0x20
popq %r14
cmpq %r12, %r15
je 0x65d3
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3210
movl 0x20(%r15), %esi
movq %rax, %rdi
callq 0x3320
movq %r15, %rdi
callq 0x3200
movq %rax, %r15
jmp 0x65aa
movq 0x2b9de(%rip), %rdi     # 0x31fb8
callq 0x30e0
leaq -0x60(%rbp), %rdi
callq 0x4202
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6601
jmp 0x6601
jmp 0x6601
jmp 0x6601
jmp 0x6601
jmp 0x6601
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_modifiers.cpp
// Function: test_set_modifiers_erase_position()
void
test_set_modifiers_erase_position()
{
	ft::set<int> set;

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

	print_set_info(set);

	set.erase(set.find(4));
	set.erase(set.find(2));

	print_set_info(set);

	while (!set.empty())
		set.erase(set.begin());

	print_set_info(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x40(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
xorl %eax, %eax
leaq -0x48(%rbp), %rbx
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
jge 0x665d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73c8
movl -0x14(%rbp), %eax
incl %eax
jmp 0x6643
leaq -0x48(%rbp), %rdi
callq 0x4ccd
leaq -0x14(%rbp), %rsi
movl $0x4, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0x7312
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x752e
leaq -0x14(%rbp), %rsi
movl $0x2, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0x7312
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x752e
leaq -0x48(%rbp), %rdi
callq 0x4ccd
leaq -0x48(%rbp), %rbx
cmpq $0x0, -0x20(%rbp)
je 0x66c6
movq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x752e
jmp 0x66b1
leaq -0x48(%rbp), %rdi
callq 0x4ccd
leaq -0x48(%rbp), %rdi
callq 0x4202
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x66e9
jmp 0x66e9
jmp 0x66e9
jmp 0x66e9
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/DimitriDaSilva[P]42_ft_containers/tester/containers/set/test_set_modifiers.cpp
// Function: test_set_modifiers_erase_value()
void
test_set_modifiers_erase_value()
{
	ft::set<int> set;

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

	print_set_info(set);

	std::cout << set.erase(4) << std::endl;
	std::cout << set.erase(4) << std::endl;
	std::cout << set.erase(2) << std::endl;

	print_set_info(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x40(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
xorl %eax, %eax
leaq -0x48(%rbp), %rbx
leaq -0x14(%rbp), %r14
movl %eax, -0x14(%rbp)
cmpl $0xa, %eax
jge 0x6745
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73c8
movl -0x14(%rbp), %eax
incl %eax
jmp 0x672b
leaq -0x48(%rbp), %rdi
callq 0x4ccd
leaq -0x14(%rbp), %rsi
movl $0x4, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0x758e
movq 0x2b850(%rip), %rdi     # 0x31fb8
movq %rax, %rsi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
leaq -0x14(%rbp), %rsi
movl $0x4, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0x758e
movq 0x2b826(%rip), %rdi     # 0x31fb8
movq %rax, %rsi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
leaq -0x14(%rbp), %rsi
movl $0x2, (%rsi)
leaq -0x48(%rbp), %rdi
callq 0x758e
movq 0x2b7fc(%rip), %rdi     # 0x31fb8
movq %rax, %rsi
callq 0x3140
movq %rax, %rdi
callq 0x30e0
leaq -0x48(%rbp), %rdi
callq 0x4ccd
leaq -0x48(%rbp), %rdi
callq 0x4202
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x67ef
jmp 0x67ef
jmp 0x67ef
jmp 0x67ef
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4202
movq %rbx, %rdi
callq 0x3330