LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::map<std::string, T, Compare, Alloc>& theMap, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(theMap))
			return;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1afae
testb %al, %al
je 0x1df09
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1defe
callq 0x21a22
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe4dc(%rip), %rsi      # 0x2c402
leaq 0xe4ee(%rip), %rdx      # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xe49b(%rip), %rsi      # 0x2c3dc
leaq 0xe4f1(%rip), %rdx      # 0x2c439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2e3, %ecx            # imm = 0x2E3
callq 0x2b040
leaq 0x19d6f(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x19d47(%rip), %rsi     # 0x37cb8
leaq 0x5a02(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1dfa2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1dfa2
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1dfb4
movq %rbx, %rdi
callq 0x131a0
jmp 0x1dfb4
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1dfc3
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::unordered_map<std::string, T, Hash, Pred, Alloc>& theMap, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(theMap))
			return;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1b1ec
testb %al, %al
je 0x1e351
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1e346
callq 0x21a22
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe094(%rip), %rsi      # 0x2c402
leaq 0xe0a6(%rip), %rdx      # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xe053(%rip), %rsi      # 0x2c3dc
leaq 0xe0a9(%rip), %rdx      # 0x2c439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2ed, %ecx            # imm = 0x2ED
callq 0x2b040
leaq 0x19927(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x198ff(%rip), %rsi     # 0x37cb8
leaq 0x55ba(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1e3ea
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1e3ea
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1e3fc
movq %rbx, %rdi
callq 0x131a0
jmp 0x1e3fc
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1e40b
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.h
// Function: bool swxJson::Json::addBasicValue<bool>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
inline bool addBasicValue(const std::string& key, TYPE value)
	{
		//JsonPtr node(new Json(value));
		JsonPtr node(new Json());
		(*node) = value;
		return addNode(key, node);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x20(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x21950
movq -0x8(%r15), %rdi
movl %ebp, %esi
callq 0x24a70
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x23625
movq 0x149b9(%rip), %rcx     # 0x37fd0
cmpb $0x0, (%rcx)
je 0x23621
incl 0x8(%rax)
jmp 0x23625
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24946
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23646
callq 0x21a22
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x23655
callq 0x21a22
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23679
callq 0x21a22
jmp 0x23679
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x23688
callq 0x21a22
movq %rbx, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/download.cpp
// Function: get_file(char*, unsigned int*)
char *get_file(char *filename, unsigned int *size)
{
	FILE	*file;
	char	*buffer;
	int	file_size, bytes_read;
	
	file = fopen(filename, "rb");
	if (file == NULL)
		return 0;
	fseek(file, 0, SEEK_END);
	file_size = ftell(file);
	fseek(file, 0, SEEK_SET);
	buffer = new char [file_size + 1];
	bytes_read = (int)fread(buffer, sizeof(char), file_size, file);
	if (bytes_read != file_size)
	{
		delete [] buffer;
		fclose(file);
		return 0;
	}
	fclose(file);
	buffer[file_size] = '\0';

	if (size != NULL)
	{
		*size = file_size;
	}

	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xcd0(%rip), %rsi       # 0x2004
callq 0x1190
testq %rax, %rax
je 0x13b9
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1170
movq %r14, %rdi
callq 0x1030
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1170
leal 0x1(%r12), %eax
movslq %eax, %rdi
callq 0x1040
movq %rax, %r15
movslq %r12d, %r13
movl $0x1, %esi
movq %rax, %rdi
movq %r13, %rdx
movq %r14, %rcx
callq 0x11c0
cmpl %r13d, %eax
jne 0x13a9
movq %r14, %rdi
callq 0x1150
movb $0x0, (%r15,%r13)
testq %rbx, %rbx
je 0x13bc
movl %r12d, (%rbx)
jmp 0x13bc
movq %r15, %rdi
callq 0x11a0
movq %r14, %rdi
callq 0x1150
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/download.cpp
// Function: StripChars(char const*, char*, char*)
void StripChars(const char *in, char *out, char *stripc)
{
    while (*in)
    {
    	bool flag = false;

	int length = strlen(stripc);
    	for(int i = 0; i < length; i++)
	{
		if (*in == stripc[i])
		{
			flag = true;
			break;
		}
	}

	if (flag)
	{
		in++;
		continue;
	}
        *out++ = *in++;
    }
    *out = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movb (%rdi), %r12b
testb %r12b, %r12b
je 0x1841
movq %rdx, %r14
movq %rdi, %r15
movq %r14, %rdi
callq 0x10d0
testl %eax, %eax
jle 0x182f
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpb (%r14,%rcx), %r12b
je 0x1835
incq %rcx
cmpq %rcx, %rax
jne 0x1821
movb %r12b, (%rbx)
incq %rbx
movb 0x1(%r15), %r12b
incq %r15
testb %r12b, %r12b
jne 0x180e
movb $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/download.cpp
// Function: main
int main(int argc, char *argv[])
{
	unsigned short port = 65535;
	unsigned int size = 0;

	if (argc < 4)
	{
		printf("Usage: download ip port max_size\r\n");
		return 0;
	}

	port = atoi(argv[2]);
	size = atoi(argv[3]);

	printf("Allocating %d bytes\r\n", size);
	char *response = (char *)malloc(size);
	if (response == NULL)
	{
		perror("malloc failed");
	}

	unsigned int download_size = 0;
	char file_name[128] = {0};

	printf("Attempting to download file from ip %s port %d\r\n", argv[1], (int)port);
	int ret = file_download(argv[1], port, response, size, &download_size, file_name);
	if (ret != 0)
	{
		printf("Download failed\r\n");
		return 0;
	}

	printf("Download complete\r\n");
	printf("Got %d bytes file name %s\r\n", download_size, file_name);

	char new_filename[256] = {0};
	char strip_filename[256] = {0};

	StripChars(file_name, strip_filename, (char *)".\\/;:*?\"<>|");

	sprintf(new_filename, "downloaded_%s", strip_filename);
	printf("Saving as file name %s\r\n", new_filename);
	write_file(new_filename, response, download_size);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
cmpl $0x3, %edi
jg 0x1872
leaq 0xa35(%rip), %rdi       # 0x22a2
jmp 0x191f
movq %rsi, %r14
movq 0x10(%rsi), %rdi
callq 0x11e0
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x11e0
movl %eax, %r12d
leaq 0x81d(%rip), %rdi       # 0x20b1
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movl %r12d, %edi
callq 0x11b0
movq %rax, %r13
testq %rax, %rax
je 0x19d2
leaq -0x2c(%rbp), %rax
movl $0x0, (%rax)
xorps %xmm0, %xmm0
leaq -0xb0(%rbp), %rbx
movaps %xmm0, 0x70(%rbx)
movaps %xmm0, 0x60(%rbx)
movaps %xmm0, 0x50(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq 0x8(%r14), %rsi
movzwl %r15w, %edx
leaq 0x7e2(%rip), %rdi       # 0x20d5
xorl %eax, %eax
callq 0x1060
movq 0x8(%r14), %rdi
movzwl %r15w, %esi
movq %r13, %rdx
movl %r12d, %ecx
leaq -0x2c(%rbp), %r8
movq %rbx, %r9
callq 0x144b
testl %eax, %eax
je 0x1938
leaq 0x972(%rip), %rdi       # 0x2291
callq 0x11d0
xorl %eax, %eax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x93f(%rip), %rdi       # 0x227e
callq 0x11d0
movl -0x2c(%rbp), %r14d
leaq 0x7b7(%rip), %rdi       # 0x2106
movl %r14d, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
leaq -0x2b0(%rbp), %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x1100
leaq -0x1b0(%rbp), %r12
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
xorl %esi, %esi
callq 0x1100
leaq 0x793(%rip), %rdx       # 0x2122
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17f2
leaq 0x78d(%rip), %rsi       # 0x212e
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1080
leaq 0x787(%rip), %rdi       # 0x213c
movq %r15, %rsi
xorl %eax, %eax
callq 0x1060
movq %r15, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x13ce
jmp 0x1924
leaq 0x6ee(%rip), %rdi       # 0x20c7
callq 0x1130
jmp 0x18b1
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/word_transform.cc
// Function: transform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
const string& transform(const string& s, const map<string, string>& m)
{
	// the actual map work; this part is the heart of the program
	auto map_it = m.find(s);
	// if this word is in the transformation map
	if (map_it != m.cend())
		return map_it->second; // use the replacement word
	else
		return s;              // otherwise return the original unchanged
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x3206
addq $0x8, %rbx
leaq 0x40(%rax), %rcx
cmpq %rbx, %rax
cmoveq %r14, %rcx
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/word_transform.cc
// Function: main
int main(int argc, char **argv)
{
	// open and check both files
	if (argc != 3)
		throw runtime_error("wrong number of arguments");

	ifstream map_file(argv[1]); // open transformation file
	if (!map_file)              // check that open succeeded
		throw runtime_error("no transformation file");

	ifstream input(argv[2]);    // open file of text to transform
	if (!input)                 // check that open succeeded
		throw runtime_error("no input file");

	word_transform(map_file, input);

	return 0;  // exiting main will automatically close the files
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
cmpl $0x3, %edi
jne 0x2a5e
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq -0x420(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x400(%rbp,%rax)
jne 0x2a90
movq 0x10(%rbx), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x2270
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
jne 0x2ac4
leaq -0x420(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x262f
leaq -0x218(%rbp), %rdi
callq 0x2070
leaq -0x420(%rbp), %rdi
callq 0x2070
xorl %eax, %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %r14
leaq 0x15d1(%rip), %rsi      # 0x4043
movq %rax, %rdi
callq 0x20b0
movq 0x356f(%rip), %rsi      # 0x5ff0
movq 0x3540(%rip), %rdx      # 0x5fc8
movq %r14, %rdi
callq 0x2240
movl $0x10, %edi
callq 0x20e0
movq %rax, %r14
leaq 0x15b9(%rip), %rsi      # 0x405d
movq %rax, %rdi
callq 0x20b0
movq 0x353d(%rip), %rsi      # 0x5ff0
movq 0x350e(%rip), %rdx      # 0x5fc8
movq %r14, %rdi
callq 0x2240
jmp 0x2af6
movl $0x10, %edi
callq 0x20e0
movq %rax, %r14
leaq 0x159c(%rip), %rsi      # 0x4074
movq %rax, %rdi
callq 0x20b0
movq 0x3509(%rip), %rsi      # 0x5ff0
movq 0x34da(%rip), %rdx      # 0x5fc8
movq %r14, %rdi
callq 0x2240
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
jmp 0x2b27
jmp 0x2b1f
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
jmp 0x2b33
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
jmp 0x2b3f
movq %rax, %rbx
jmp 0x2b33
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2070
leaq -0x420(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_vectornorm.cpp
// Function: double norm<double>::norm_impl<11u>(exprtk::type_store<double>::type_view<double> const&, unsigned long, unsigned long)
inline T norm_impl(const vector_t& vector, const std::size_t r0, const std::size_t r1)
   {
      T sum = T(0);

      for (std::size_t i = r0; i <= r1; ++i)
      {
         sum += exprtk::details::numeric::fast_exp<T,Pow>::result(std::abs(vector[i]));
      }

      switch (Pow)
      {
         case 1  : return sum;
         case 2  : return exprtk::details::numeric::sqrt(sum);
         default : return exprtk::details::numeric::pow(sum, T(1) / Pow);
      }
   }

// Assembly:
xorpd %xmm0, %xmm0
cmpq %rcx, %rdx
ja 0x11e9f5
movq 0x8(%rsi), %rax
movapd 0x1a868b(%rip), %xmm1   # 0x2c7040
movsd 0x1a86fb(%rip), %xmm2   # 0x2c70b8
movsd (%rax,%rdx,8), %xmm3
andpd %xmm1, %xmm3
movl $0xb, %esi
movapd %xmm2, %xmm4
testb $0x1, %sil
je 0x11e9d9
mulsd %xmm3, %xmm4
movl %esi, %edi
andl $-0x2, %edi
mulsd %xmm3, %xmm3
shrl %esi
cmpl $0x1, %edi
ja 0x11e9cf
addsd %xmm4, %xmm0
incq %rdx
cmpq %rcx, %rdx
jbe 0x11e9bd
movsd 0x1a8713(%rip), %xmm1   # 0x2c7110
jmp 0x116180
// File: /workspace/github_cpp_makefile_star2_O1/zengfenfei[P]codility/src/PassingCars.cpp
// Function: solution(std::vector<int, std::allocator<int>>&)
int solution(vector<int> &A) {
	int carsToEast = 0;
	int pairs = 0;
	for (int i = 0; i < A.size(); i++) {
		if (A[i] == 0) {
			carsToEast++;
		} else {
			pairs += carsToEast;
		}
		if (pairs > 1000000000) {
			return -1;
		}
	}
	return pairs;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
je 0x1229
pushq %rbp
movq %rsp, %rbp
sarq $0x2, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
xorl %eax, %eax
xorl %edi, %edi
movl %eax, %r9d
movl (%rcx,%rsi,4), %r8d
testl %r8d, %r8d
movl %edi, %eax
cmovel %r8d, %eax
addl %r9d, %eax
cmpl $0x3b9aca00, %eax       # imm = 0x3B9ACA00
ja 0x122c
cmpl $0x1, %r8d
adcl $0x0, %edi
incq %rsi
cmpq %rsi, %rdx
jne 0x11fe
jmp 0x1231
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zengfenfei[P]codility/src/PassingCars.cpp
// Function: main
int main() {
	vector<int> A(5);
	A[0] = 0;
	A[1] = 1;
	A[2] = 0;
	A[3] = 1;
	A[4] = 1;

	cout << solution(A) << '\n';	// 5
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x14, %edi
callq 0x1040
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x1, 0x4(%rax)
movl $0x1, %eax
movl %eax, 0xc(%rbx)
movl %eax, 0x10(%rbx)
xorl %eax, %eax
xorl %esi, %esi
xorl %ecx, %ecx
movl %esi, %edi
movl (%rbx,%rax,4), %edx
testl %edx, %edx
movl %ecx, %esi
cmovel %edx, %esi
addl %edi, %esi
cmpl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
ja 0x1291
cmpl $0x1, %edx
adcl $0x0, %ecx
incq %rax
cmpq $0x5, %rax
jne 0x126a
jmp 0x1296
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq 0x2d3b(%rip), %rdi      # 0x3fd8
callq 0x1080
leaq -0x11(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1060
movl $0x14, %esi
movq %rbx, %rdi
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x14, %esi
movq %rbx, %rdi
callq 0x1050
movq %r14, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<MulticolorValue, true>::print_simple(std::ostream&)
void print_simple(std::ostream &os) {
		for(int i = 0; i < height; ++i) {
			if(i == 0) {
				field[0].begin_screen(os);
			}

			for(int j = 0; j < width; ++j) {
				if(j == 0) {
					field[i * width].begin_line(os);
				}

				field[i * width + j].print(os);

				if(j == width - 1) {
					field[i * width + j].end_line(os);
				}
			}

			if(i == height - 1) {
				field[i].end_screen(os);
			}
		}
		os << std::flush;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, 0x18(%rdi)
jle 0x5531
movq %rdi, %r14
xorl %r13d, %r13d
movq 0x4af7(%rip), %r15      # 0x9fc8
leaq 0x1d94(%rip), %r12      # 0x726c
movl 0x1c(%r14), %eax
testl %eax, %eax
jle 0x5505
xorl %ebp, %ebp
imull %r13d, %eax
cltq
addq %rbp, %rax
leaq (%rax,%rax,4), %rdi
addq (%r14), %rdi
movq %rbx, %rsi
callq 0x6390
movl 0x1c(%r14), %eax
incq %rbp
cmpl %eax, %ebp
jl 0x54e2
movl 0x18(%r14), %eax
decl %eax
cmpl %eax, %r13d
jne 0x5528
movl $0x6, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x2100
incl %r13d
cmpl 0x18(%r14), %r13d
jl 0x54d8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/sgielen[P]clife/multicolor.cpp
// Function: MulticolorValue::print(std::ostream&) const
void print(std::ostream &os) const {
		if(value && to_ledscreen) {
			os << red << green << blue;
		} else if(value) {
			double brightness = std::max(0.3, 1 - age / 20.);

			uint8_t redval = (red * brightness) / 43;
			uint8_t greenval = (green * brightness) / 43;
			uint8_t blueval = (blue * brightness) / 43;
			uint8_t code = 16 + 36 * redval + 6 * greenval + blueval;
			os << "\x1b[38;5;" << int(code) << "mo\x1b[m";
		} else if(to_ledscreen) {
			os << '\x00' << '\x00' << '\x00';
		} else {
			os << ' ';
		}
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x1, (%rdi)
jne 0x6458
movzbl 0x4(%rdi), %eax
cvtsi2sd %eax, %xmm0
divsd 0xc99(%rip), %xmm0      # 0x7048
addsd 0xc99(%rip), %xmm0      # 0x7050
maxsd 0xc99(%rip), %xmm0      # 0x7058
movzbl 0x1(%rdi), %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm0, %xmm1
movsd 0xc8d(%rip), %xmm2      # 0x7060
divsd %xmm2, %xmm1
cvttsd2si %xmm1, %eax
movzbl 0x2(%rdi), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm2, %xmm1
cvttsd2si %xmm1, %ecx
movzbl 0x3(%rdi), %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm2, %xmm1
cvttsd2si %xmm1, %edx
shll $0x2, %eax
leal (%rax,%rax,8), %ebp
addl %ecx, %ecx
leal (%rcx,%rcx,2), %eax
addb %dl, %bpl
addb %al, %bpl
addb $0x10, %bpl
leaq 0xe39(%rip), %rsi       # 0x725e
movl $0x7, %edx
movq %rbx, %rdi
callq 0x21d0
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x22a0
leaq 0xe21(%rip), %rsi       # 0x7266
movl $0x5, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d0
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21d0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/rollhash_x.c
// Function: main
int main(void)
{
    plan_tests(14);

    uint8_t test[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    uint32_t i, arg = rollhash_arg(12), roll = rollhash_init(test, 12);

    for (i = 0; i < 26 - 12; i++) {
        uint hash = rollhash_init(test + i + 1, 12);
        roll = rollhash_step(arg, roll, test[i], test[i+12]);
        ok(roll == hash, "-%c +%c", test[i], test[i+12]);
    }   

    return exit_status();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xe, %edi
callq 0x1cda
movl $0x26e6e0, %r14d        # imm = 0x26E6E0
leaq 0x1cf2(%rip), %r15      # 0x3010
leaq 0x1d0b(%rip), %r13      # 0x3030
leaq 0x1cff(%rip), %rbx      # 0x302b
movq %r15, %rbp
xorl %r12d, %r12d
movl $0x1, %ecx
xorl %eax, %eax
shll $0x8, %eax
movzbl (%rbp,%rcx), %edx
orl %eax, %edx
imulq $0x40400041, %rdx, %rax # imm = 0x40400041
shrq $0x35, %rax
imull $0x7f807f, %eax, %esi   # imm = 0x7F807F
movl %edx, %eax
subl %esi, %eax
incq %rcx
cmpl $0xd, %ecx
jne 0x1339
movzbl (%r12,%r15), %r10d
movzbl 0xc(%r12,%r15), %r11d
imull $0xfffafdf0, %r10d, %ecx # imm = 0xFFFAFDF0
addl %ecx, %r14d
addl $0x7f807f00, %r14d      # imm = 0x7F807F00
imulq $0x40400041, %r14, %rcx # imm = 0x40400041
shrq $0x35, %rcx
imull $0x7f807f, %ecx, %ecx   # imm = 0x7F807F
subl %ecx, %r14d
shll $0x8, %r14d
orl %r11d, %r14d
imulq $0x40400041, %r14, %rcx # imm = 0x40400041
shrq $0x35, %rcx
imull $0x7f807f, %ecx, %ecx   # imm = 0x7F807F
subl %ecx, %r14d
xorl %esi, %esi
cmpl %eax, %r14d
sete %sil
subq $0x8, %rsp
xorl %edi, %edi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
xorl %eax, %eax
pushq %r11
pushq %r10
leaq 0x1c6c(%rip), %r10      # 0x303d
pushq %r10
pushq $0xe
pushq %r13
callq 0x1404
addq $0x30, %rsp
incq %r12
incq %rbp
cmpq $0xe, %r12
jne 0x1332
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f7e
nop
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<double>::SimpleThreadPool(unsigned int, unsigned int)
SimpleThreadPool(unsigned int max_thread_size, unsigned int max_job_size)
	{
		m_oTrdList.set_thread_func(boost::bind(&SimpleThreadPool::dispatch_thread, this));
		m_oTrdList.set_max_thread_num(max_thread_size);
		m_oJobList.set_max_job_num(max_job_size);
		m_bStopFlag = false;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
callq 0x6a6a
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x6ab0
leaq 0x170(%rbx), %r15
movq %r15, %rdi
callq 0x6b74
leaq 0xebf(%rip), %rax       # 0x6c3e
movq %rsp, %rsi
movq %rax, 0x8(%rsi)
movq $0x0, 0x10(%rsi)
movq %rbx, 0x18(%rsi)
leaq 0xc940(%rip), %rax      # 0x126d9
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x6bd6
movq %rsp, %rdi
callq 0x6cf0
movq %r15, %rdi
movl %r12d, %esi
callq 0x6d28
movq %r14, %rdi
movl %ebp, %esi
callq 0x6de8
movb $0x0, 0x1d8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %rsp, %rdi
callq 0x6cf0
jmp 0x5def
movq %rax, %r12
jmp 0x5df7
movq %rax, %r12
jmp 0x5dff
movq %rax, %r12
movq %r15, %rdi
callq 0x6e32
movq %r14, %rdi
callq 0x6f44
movq %rbx, %rdi
callq 0x6f84
movq %r12, %rdi
callq 0x53f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<double>::add_job_block(Switch::Tool::SimpleJob<void> const&)
bool add_job_block(const SimpleJob< void >& job)
	{
		m_oJobList.lock_add_job();
		m_oJobList.wait_add_job();
		if (m_bStopFlag)
		{
			m_oJobList.unlock_add_job();
			return false;
		}
		bool ret = m_oJobList.push_back(job);
		m_oJobList.unlock_add_job();
		if (ret)
		{
			m_oJobList.notify_one_get_job();
		}

		return ret;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rdi), %r12
leaq 0x68(%rdi), %r14
movq %r14, %rdi
callq 0x7864
movq %r12, %rdi
callq 0x945e
cmpb $0x1, 0x1d8(%rbx)
jne 0x5f4b
movq %r14, %rdi
callq 0x7e50
xorl %ebp, %ebp
jmp 0x5f74
movq %r12, %rdi
movq %r15, %rsi
callq 0x9494
movl %eax, %ebp
movq %r14, %rdi
callq 0x7e50
testb %bpl, %bpl
je 0x5f74
addq $0x110, %rbx            # imm = 0x110
movq %rbx, %rdi
callq 0x9602
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<float>::SetMaxPoolSize(unsigned int)
int SetMaxPoolSize(unsigned int size)
	{
        m_TMutex.lock();
        if (size > m_nMaxPoolSize || size >= m_lpThread.size())
        {
            m_nMaxPoolSize = size;
            m_TMutex.unlock();
            return 0;
        }
        m_TMutex.unlock();

        return -1;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7864
cmpl %ebp, 0x48(%rbx)
jb 0x6051
movl %ebp, %eax
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpq %rax, 0x38(%rbx)
ja 0x6057
movl %ebp, 0x48(%rbx)
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x7e50
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: int Switch::Tool::SimpleThreadPool<float>::AddThread<boost::_bi::bind_t<double, double (*)(void*), boost::_bi::list1<boost::_bi::value<void*>>>>(boost::_bi::bind_t<double, double (*)(void*), boost::_bi::list1<boost::_bi::value<void*>>>)
int	AddThread(T func)
	{
	    m_TMutex.lock();
		if (m_lpThread.size() >= m_nMaxPoolSize) {
            m_TMutex.unlock();
			return -1;
		}

        m_lpThread.push_back(new boost::thread(func));
        m_TMutex.unlock();

		return 0;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
callq 0x7864
movl 0x48(%rbx), %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %rax, 0x38(%rbx)
jae 0x60cf
movl $0x10, %edi
callq 0x5250
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xac3a
leaq 0x28(%rbx), %r15
movl $0x18, %edi
callq 0x5250
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x5050
incq 0x38(%rbx)
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x7e50
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<float>::StopThreadPool()
int StopThreadPool(void)
	{
        std::list< boost::thread* >::iterator iter, end;

        end = m_lpThread.end();
        for (iter = m_lpThread.begin(); iter != end;)
        {
            boost::thread* p = *iter;
            p->interrupt();
            p->join();
            delete p;
        }

        return 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r12
addq $0x28, %rbx
cmpq %rbx, %r12
je 0x61e2
movq 0x10(%r12), %r14
movq %r14, %rdi
callq 0x5300
movq %r14, %rdi
callq 0x5070
movq %rax, %r15
callq 0x5220
cmpq %r15, %rax
je 0x61f0
movq %r14, %rdi
callq 0x52f0
movq %r14, %rdi
callq 0x9440
movl $0x10, %esi
movq %r14, %rdi
callq 0x5270
jmp 0x619c
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x65c9(%rip), %rsi      # 0xc7c0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5420
movabsq $0x100000023, %rax      # imm = 0x100000023
movq %rax, 0x10(%rbx)
leaq 0xc017(%rip), %rax      # 0x12230
movq %rax, 0x18(%rbx)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0xc158(%rip), %rcx      # 0x12390
movq %rcx, -0x30(%rax)
movq %rbx, %rdi
callq 0x6fba
movq %rax, %rdi
callq 0x5c4a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6442
movq %rbx, %rdi
callq 0x53f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<float>::~SimpleThreadPool()
~SimpleThreadPool(void)
	{
	    m_pJoinThread->interrupt();
	    m_pJoinThread->join();
	    delete m_pJoinThread;

        StopThreadPool();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x5300
movq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x5070
movq %rax, %r15
callq 0x5220
cmpq %r15, %rax
je 0x62f1
movq %r14, %rdi
callq 0x52f0
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x62b6
movq %r14, %rdi
callq 0x9440
movl $0x10, %esi
movq %r14, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x6186
leaq 0x28(%rbx), %r14
movq 0x28(%rbx), %rdi
cmpq %r14, %rdi
je 0x62e0
movq (%rdi), %r15
movl $0x18, %esi
callq 0x5270
movq %r15, %rdi
cmpq %r14, %r15
jne 0x62cb
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6f84
leaq 0x64c8(%rip), %rsi      # 0xc7c0
movq %rsp, %rdi
callq 0x5420
movabsq $0x100000023, %rax      # imm = 0x100000023
leaq 0x30(%rsp), %rcx
movq %rax, -0x20(%rcx)
leaq 0xbf16(%rip), %rax      # 0x12230
movq %rax, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0xc05c(%rip), %rax      # 0x12390
movq %rax, -0x30(%rcx)
movq %rsp, %rdi
callq 0x6fba
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6442
jmp 0x6358
movq %rax, %rdi
callq 0x5c4a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5c4a
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<double>::dispatch_thread()
void dispatch_thread(void)
	{
		SimpleJob< void > job;

		while (1)
		{
			m_oJobList.lock_get_job();
			m_oJobList.wait_get_job();
			if (m_bStopFlag)
			{
				m_oJobList.unlock_get_job();
				return;
			}
			m_oJobList.pop_front(job);
			m_oJobList.unlock_get_job();
			m_oJobList.notify_all_add_job();
			job.CallJob();
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x7e86
leaq 0x28(%rbx), %r12
leaq 0xe8(%rbx), %r15
leaq 0x90(%rbx), %r13
movq %r15, %rdi
callq 0x7864
movq %r12, %rdi
callq 0x7eb8
cmpb $0x1, 0x1d8(%rbx)
je 0x6ca9
movq %r12, %rdi
movq %r14, %rsi
callq 0x7ef4
movq %r15, %rdi
callq 0x7e50
movq %r13, %rdi
callq 0x878a
movq %r14, %rdi
callq 0x7f78
jmp 0x6c6b
movq %r15, %rdi
callq 0x7e50
leaq 0x20(%rsp), %rdi
callq 0x6f84
movq %rsp, %rdi
callq 0x6cf0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x6cd3
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6f84
movq %rsp, %rdi
callq 0x6cf0
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleThreadList.hpp
// Function: Switch::Tool::SimpleThreadList::set_max_thread_num(unsigned int)
bool set_max_thread_num(unsigned int max)
    {
        boost::lock_guard< boost::mutex > guard(m_oMutex);

        if (m_bStopFlag || max <= m_nMaxThreadNum)
        {
            return false;
        }

        for (unsigned int i = m_nMaxThreadNum; i < max; ++i)
        {
            m_lpThread.push_back(new boost::thread(m_oFunc));
        }
        m_nMaxThreadNum = max;

        return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x7864
cmpb $0x0, 0x64(%r14)
jne 0x6d9e
movl 0x60(%r14), %r13d
cmpl %ebp, %r13d
jae 0x6d9e
leaq 0x40(%r14), %r15
movl $0x10, %edi
callq 0x5250
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x8cd4
movl $0x18, %edi
callq 0x5250
movq %r12, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x5050
incq 0x10(%r14)
incl %r13d
cmpl %r13d, %ebp
jne 0x6d58
movl %ebp, 0x60(%r14)
movb $0x1, %bpl
jmp 0x6da0
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x7e50
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6de0
movq %rax, %r14
movl $0x10, %esi
movq %r12, %rdi
callq 0x5270
jmp 0x6dd0
movq %rax, %r14
movq %rbx, %rdi
callq 0x7e50
movq %r14, %rdi
callq 0x53f0
movq %rax, %rdi
callq 0x5c4a
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleJob.hpp
// Function: Switch::Tool::SimpleJobList::set_max_job_num(unsigned int)
bool set_max_job_num(unsigned int max)
    {
        boost::lock_guard< boost::mutex > guard(m_oMutex);

        if (max <= m_nMaxJobNum)
        {
            return false;
        }
        m_nMaxJobNum = max;

        return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x7864
movl 0x140(%r15), %ebp
cmpl %ebx, %ebp
jae 0x6e12
movl %ebx, 0x140(%r15)
movq %r14, %rdi
callq 0x7e50
cmpl %ebx, %ebp
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x5c4a
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleThreadList.hpp
// Function: Switch::Tool::SimpleThreadList::~SimpleThreadList()
~SimpleThreadList(void)
    {
    	iterator iter, end;
    	end = m_lpThread.end();
    	for (iter = m_lpThread.begin(); iter != end; ++iter)
		{
			(*iter)->join();
			delete (*iter);
		}
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdi), %r12
cmpq %rdi, %r12
je 0x6e92
movq 0x10(%r12), %r14
movq %r14, %rdi
callq 0x5070
movq %rax, %r15
callq 0x5220
cmpq %r15, %rax
je 0x6ecd
movq %r14, %rdi
callq 0x52f0
movq 0x10(%r12), %r14
testq %r14, %r14
je 0x6e89
movq %r14, %rdi
callq 0x9440
movl $0x10, %esi
movq %r14, %rdi
callq 0x5270
movq (%r12), %r12
cmpq %rbx, %r12
jne 0x6e48
leaq 0x40(%rbx), %rdi
callq 0x6cf0
leaq 0x18(%rbx), %rdi
callq 0x6f84
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x6ec1
movq (%rdi), %r14
movl $0x18, %esi
callq 0x5270
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x6eac
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x58ec(%rip), %rsi      # 0xc7c0
leaq 0x8(%rsp), %rdi
callq 0x5420
movabsq $0x100000023, %rax      # imm = 0x100000023
leaq 0x38(%rsp), %rcx
movq %rax, -0x20(%rcx)
leaq 0xb338(%rip), %rax      # 0x12230
movq %rax, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0xb47e(%rip), %rax      # 0x12390
movq %rax, -0x30(%rcx)
leaq 0x8(%rsp), %rdi
callq 0x6fba
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6442
jmp 0x6f3c
jmp 0x6f39
movq %rax, %rdi
callq 0x5c4a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5c4a
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleJob.hpp
// Function: Switch::Tool::SimpleJobList::pop_front(Switch::Tool::SimpleJob<void>&)
bool pop_front(SimpleJob< void >& job)
    {
		boost::lock_guard< boost::mutex > guard(m_oMutex);

		if (!m_bStopFlag || m_lJobList.size() > 0)
		{
			job = m_lJobList.front();
			m_lJobList.pop_front();

			return true;
		}

		return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x7864
cmpq $0x0, 0x10(%r14)
sete %bpl
andb 0x144(%r14), %bpl
jne 0x7f44
movq (%r14), %r12
leaq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x77ee
movl 0x58(%r12), %eax
movl %eax, 0x48(%r15)
movq (%r14), %rsi
movq %r14, %rdi
callq 0x874e
movq %rbx, %rdi
callq 0x7e50
xorb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7e50
movq %r14, %rdi
callq 0x53f0
jmp 0x7f70
movq %rax, %rdi
callq 0x5c4a
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleJob.hpp
// Function: Switch::Tool::SimpleJob<void>::CallJob()
void CallJob(void)
    {
        m_oMutex.lock();
        m_eStat = SJS_CALL;
        m_oMutex.unlock();

        m_oFunc();

        m_oMutex.lock();
        m_eStat = SJS_DONE;
        m_oMutex.unlock();
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x7864
movl $0x2, 0x48(%rbx)
movq %r14, %rdi
callq 0x7e50
movq %rbx, %rdi
callq 0x8866
movq %r14, %rdi
callq 0x7864
movl $0x3, 0x48(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7e50
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleJob.hpp
// Function: Switch::Tool::SimpleJobList::push_back(Switch::Tool::SimpleJob<void> const&)
bool push_back(const SimpleJob< void >& job)
    {
        boost::lock_guard< boost::mutex > guard(m_oMutex);

        if (m_bStopFlag || m_lJobList.size() >= m_nMaxJobNum)
        {
            return false;
        }

        m_lJobList.push_back(job);

        return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x7864
cmpb $0x0, 0x144(%r14)
jne 0x94e3
movl 0x140(%r14), %eax
cmpq %rax, 0x10(%r14)
jae 0x94e3
movq %r14, %rdi
movq %r15, %rsi
callq 0x9568
movq %rax, %rdi
movq %r14, %rsi
callq 0x5050
incq 0x10(%r14)
movb $0x1, %bpl
jmp 0x94e5
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x7e50
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7e50
movq %r14, %rdi
callq 0x53f0
jmp 0x950f
movq %rax, %rdi
callq 0x5c4a
nop
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleJob.hpp
// Function: Switch::Tool::SimpleJobList::stop()
void stop(void)
    {
    	boost::lock_guard< boost::mutex > guard(m_oMutex);
    	m_bStopFlag = true;
		notify_all_add_job();
		notify_all_get_job();
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x7864
movb $0x1, 0x144(%rbx)
leaq 0x68(%rbx), %rdi
callq 0x878a
addq $0xe8, %rbx
movq %rbx, %rdi
callq 0x878a
movq %r14, %rdi
callq 0x7e50
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5c4a
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleThreadList.hpp
// Function: Switch::Tool::SimpleThreadList::stop()
void stop(void)
    {
    	boost::lock_guard< boost::mutex > guard(m_oMutex);
    	m_bStopFlag = true;

    	iterator iter, end;
    	end = m_lpThread.end();
    	for (iter = m_lpThread.begin(); iter != end; ++iter)
		{
			(*iter)->join();
			delete (*iter);
		}
		m_lpThread.clear();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x7864
movb $0x1, 0x64(%r14)
movq (%r14), %r13
cmpq %r14, %r13
je 0x9712
movq 0x10(%r13), %r15
movq %r15, %rdi
callq 0x5070
movq %rax, %r12
callq 0x5220
cmpq %r12, %rax
je 0x9730
movq %r15, %rdi
callq 0x52f0
movq 0x10(%r13), %r15
testq %r15, %r15
je 0x970c
movq %r15, %rdi
callq 0x9440
movl $0x10, %esi
movq %r15, %rdi
callq 0x5270
movq (%r13), %r13
jmp 0x96c8
movq %r14, %rdi
callq 0x97ae
movq %rbx, %rdi
callq 0x7e50
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3089(%rip), %rsi      # 0xc7c0
movq %rsp, %rdi
callq 0x5420
movabsq $0x100000023, %rax      # imm = 0x100000023
leaq 0x30(%rsp), %rcx
movq %rax, -0x20(%rcx)
leaq 0x8ad7(%rip), %rax      # 0x12230
movq %rax, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0x8c1d(%rip), %rax      # 0x12390
movq %rax, -0x30(%rcx)
movq %rsp, %rdi
callq 0x6fba
jmp 0x97a5
movq %rax, %r14
movq %rsp, %rdi
callq 0x6442
jmp 0x9795
jmp 0x9792
jmp 0x97a5
movq %rax, %r14
movq %rbx, %rdi
callq 0x7e50
movq %r14, %rdi
callq 0x53f0
movq %rax, %rdi
callq 0x5c4a
nop
// File: /workspace/github_cpp_makefile_star2_O1/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<float>::ThreadJoin()
void ThreadJoin(void)
    {
        std::list< boost::thread* >::iterator iter, end;

        while(1)
        {
            m_TMutex.lock();
            end = m_lpThread.end();
            for (iter = m_lpThread.begin(); iter != end;)
            {
                if ((*iter)->timed_join(boost::posix_time::microseconds(1)))
                {
                    boost::thread* p = *iter;
                    iter = m_lpThread.erase(iter);
                    delete p;
                }
                else
                {
                    ++iter;
                }
            }
            m_TMutex.unlock();

            boost::this_thread::sleep(boost::posix_time::milliseconds(1));
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r13
movq %rsp, %r14
movq %rbx, %rdi
callq 0x7864
movq 0x28(%rbx), %r15
cmpq %r13, %r15
je 0x986f
movq 0x10(%r15), %rdi
movq $0x1, (%rsp)
movq %r14, %rsi
callq 0x9926
testb %al, %al
je 0x9864
movq (%r15), %rbp
movq 0x10(%r15), %r12
decq 0x38(%rbx)
movq %r15, %rdi
callq 0x53b0
movl $0x18, %esi
movq %r15, %rdi
callq 0x5270
testq %r12, %r12
je 0x9867
movq %r12, %rdi
callq 0x9440
movl $0x10, %esi
movq %r12, %rdi
callq 0x5270
jmp 0x9867
movq (%r15), %rbp
movq %rbp, %r15
cmpq %r13, %rbp
jne 0x9810
movq %rbx, %rdi
callq 0x7e50
movq $0x3e8, (%rsp)          # imm = 0x3E8
movq %r14, %rdi
callq 0x9a53
jmp 0x97ff
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day04/ex03/Character.cpp
// Function: Character::Character(Character const&)
Character::Character(const Character &other):
	name(other.name), equipped(0)
{
	for (int i = 0; i < other.equipped; i++)
		this->equip(other.inventory[i]->clone());
	for (int i = this->equipped; i < 4; i++)
		this->inventory[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x36ff(%rip), %rax      # 0x5c78
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq 0x8(%rsi), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x247a
movl $0x0, 0x28(%rbx)
cmpl $0x0, 0x28(%r15)
jle 0x25cf
xorl %r13d, %r13d
movq 0x30(%r15,%r13,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
incq %r13
movslq 0x28(%r15), %rax
cmpq %rax, %r13
jl 0x25ac
movslq 0x28(%rbx), %rax
cmpq $0x3, %rax
jg 0x2605
leaq (%rbx,%rax,8), %rdi
addq $0x30, %rdi
movl $0x3, %ecx
subl %eax, %ecx
leaq 0x8(,%rcx,8), %rdx
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x262b
movq (%r12), %rsi
incq %rsi
callq 0x20d0
movq %rbx, %rdi
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day04/ex03/Character.cpp
// Function: Character::operator=(Character const&)
Character &Character::operator=(const Character &other)
{
	this->name = other.name;
	for (int i = 0; i < this->equipped; i++)
		delete this->inventory[i];
	this->equipped = 0;
	for (int i = 0; i < other.equipped; i++)
		this->equip(other.inventory[i]->clone());
	for (int i = this->equipped; i < 4; i++)
		this->inventory[i] = 0;
	return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x2040
cmpl $0x0, 0x28(%rbx)
jle 0x26f2
xorl %r15d, %r15d
movq 0x30(%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x26e6
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jl 0x26d6
movl $0x0, 0x28(%rbx)
cmpl $0x0, 0x28(%r14)
jle 0x2726
xorl %r15d, %r15d
movq 0x30(%r14,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
incq %r15
movslq 0x28(%r14), %rax
cmpq %rax, %r15
jl 0x2703
movslq 0x28(%rbx), %rax
cmpq $0x3, %rax
jg 0x274e
leaq (%rbx,%rax,8), %rdi
addq $0x30, %rdi
movl $0x3, %ecx
subl %eax, %ecx
leaq 0x8(,%rcx,8), %rdx
xorl %esi, %esi
callq 0x2050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day04/ex03/Character.cpp
// Function: Character::equip(AMateria*)
void Character::equip(AMateria *m)
{
	if (m == 0)
		return ;
	if (this->equipped == 4)
		return ;
	for (int i = 0; i < this->equipped; i++)
	{
		if (this->inventory[i] == m)
			return ;
	}
	this->inventory[this->equipped++] = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x27b5
movl 0x28(%rdi), %eax
cmpq $0x4, %rax
je 0x27b5
testl %eax, %eax
setg %cl
jle 0x27a8
cmpq %rsi, 0x30(%rdi)
je 0x27a4
leaq -0x1(%rax), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x27a8
leaq 0x1(%rdx), %r8
cmpq %rsi, 0x38(%rdi,%rdx,8)
movq %r8, %rdx
jne 0x278b
cmpq %rax, %r8
setb %cl
testb %cl, %cl
jne 0x27b5
movslq %eax, %rcx
incl %eax
movl %eax, 0x28(%rdi)
movq %rsi, 0x30(%rdi,%rcx,8)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day04/ex03/Character.cpp
// Function: Character::unequip(int)
void Character::unequip(int idx)
{
	if (idx < 0 || idx >= this->equipped || this->inventory[idx] == 0)
		return ;
	for (int i = idx; i < 3; i++)
	{
		this->inventory[i] = this->inventory[i + 1];
		this->inventory[i + 1] = 0;
	}
	this->equipped--;
}

// Assembly:
testl %esi, %esi
js 0x27ff
movl 0x28(%rdi), %eax
cmpl %esi, %eax
jle 0x27ff
movl %esi, %ecx
cmpq $0x0, 0x30(%rdi,%rcx,8)
je 0x27ff
cmpl $0x2, %esi
jg 0x27fa
pushq %rbp
movq %rsp, %rbp
decl %esi
leaq (%rdi,%rcx,8), %rcx
addq $0x38, %rcx
movq (%rcx), %rdx
movq %rdx, -0x8(%rcx)
movq $0x0, (%rcx)
incl %esi
addq $0x8, %rcx
cmpl $0x2, %esi
jl 0x27e0
popq %rbp
decl %eax
movl %eax, 0x28(%rdi)
retq