LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/WojciechMula[P]utf16utf8/benchmarks/event_counter.h
// Function: event_count::operator+(event_count const&) const
event_count operator+(const event_count& other) const {
    return event_count(elapsed+other.elapsed, {
      event_counts[0]+other.event_counts[0],
      event_counts[1]+other.event_counts[1],
      event_counts[2]+other.event_counts[2],
      event_counts[3]+other.event_counts[3],
      event_counts[4]+other.event_counts[4],
    });
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
vmovsd (%rsi), %xmm0
movq 0x8(%rdx), %rcx
movq 0x8(%rsi), %rax
leaq 0x30(%rsp), %rsi
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
vaddsd (%rdx), %xmm0, %xmm0
vmovsd %xmm0, 0x10(%rsp)
vmovdqu (%rcx), %ymm0
vpaddq (%rax), %ymm0, %ymm0
vmovdqu %ymm0, (%rsi)
movq 0x20(%rcx), %rcx
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rsi)
pushq $0x5
popq %rdx
leaq 0xf(%rsp), %rcx
movq %r14, %rdi
vzeroupper
callq 0x5736
vmovsd 0x10(%rsp), %xmm0
leaq 0x8(%rbx), %rdi
vmovsd %xmm0, (%rbx)
movq %r14, %rsi
callq 0x5e56
leaq 0x18(%rsp), %rdi
callq 0x57ca
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %rdi
movq %rax, %rbx
callq 0x57ca
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/WojciechMula[P]utf16utf8/dependencies/utf8_v2_3_4/source/utf8/checked.h
// Function: std::back_insert_iterator<std::vector<unsigned short, std::allocator<unsigned short>>> utf8::utf8to16<std::back_insert_iterator<std::vector<unsigned short, std::allocator<unsigned short>>>, __gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>, __gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>, std::back_insert_iterator<std::vector<unsigned short, std::allocator<unsigned short>>>)
u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
    {
        while (start != end) {
            uint32_t cp = utf8::next(start, end);
            if (cp > 0xffff) { //make a surrogate pair
                *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
                *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
            }
            else
                *result++ = static_cast<uint16_t>(cp);
        }
        return result;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r13
leaq 0xa(%rsp), %rbp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, (%r15)
cmpq %r14, %rdi
je 0x618f
movq %r15, %rdi
movq %r14, %rsi
callq 0x61a1
movl %eax, %r12d
cmpl $0x10000, %eax          # imm = 0x10000
jb 0x6177
movl %r12d, %eax
shrl $0xa, %eax
leaq 0xe(%rsp), %rsi
movq %rbx, %rdi
addl $0xffffd7c0, %eax       # imm = 0xFFFFD7C0
movw %ax, 0xe(%rsp)
callq 0x3ae4
andl $0x3ff, %r12d           # imm = 0x3FF
movq %rbx, %rdi
movq %r13, %rsi
orl $0xdc00, %r12d          # imm = 0xDC00
movw %r12w, 0xc(%rsp)
jmp 0x6183
movw %r12w, 0xa(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3ae4
movq 0x10(%rsp), %rdi
jmp 0x6124
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::parseFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, tmxparser::TmxMap*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TmxReturn parseFromFile(const std::string& fileName, TmxMap* outMap, const std::string& tilesetPath)
{
	tinyxml2::XMLDocument doc;
	if (doc.LoadFile(fileName.c_str()) != tinyxml2::XML_SUCCESS)
	{
		LOGE("Cannot read xml file");
		return TmxReturn::kErrorParsing;
	}

	// parse the map node
	return _parseStart(doc.FirstChildElement("map"), outMap, tilesetPath);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x2a8(%rbp), %r13
pushq $0x1
popq %rbx
movq %r13, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0xd1a4
movq (%r12), %rsi
movq %r13, %rdi
callq 0xd360
testl %eax, %eax
jne 0x4692
leaq 0xb9d9(%rip), %rsi      # 0x1002f
leaq -0x2a8(%rbp), %rdi
callq 0xbae8
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x46d2
movl %eax, %ebx
leaq -0x2a8(%rbp), %rdi
callq 0xd2b2
movl %ebx, %eax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x14937(%rip), %r14     # 0x18fd0
movq (%r14), %rcx
leaq 0xb965(%rip), %rdi      # 0x10008
pushq $0x26
popq %rsi
pushq $0x1
popq %rdx
callq 0x4430
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x4270
jmp 0x4672
movq %rax, %rbx
leaq -0x2a8(%rbp), %rdi
callq 0xd2b2
movq %rbx, %rdi
callq 0x43d0
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::parseFromMemory(void*, unsigned long, tmxparser::TmxMap*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TmxReturn parseFromMemory(void* data, size_t length, TmxMap* outMap, const std::string& tilesetPath)
{
	tinyxml2::XMLDocument doc;
	if (doc.Parse((char*)data, length))
	{
		LOGE("Cannot parse xml memory file...");
		return TmxReturn::kErrorParsing;
	}

	return _parseStart(doc.FirstChildElement("map"), outMap, tilesetPath);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rcx, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq -0x2b0(%rbp), %r14
pushq $0x1
popq %rbx
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0xd1a4
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xd602
testl %eax, %eax
jne 0x47d4
leaq 0xb898(%rip), %rsi      # 0x1002f
leaq -0x2b0(%rbp), %rdi
callq 0xbae8
movq %rax, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq 0x46d2
movl %eax, %ebx
leaq -0x2b0(%rbp), %rdi
callq 0xd2b2
movl %ebx, %eax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x147f5(%rip), %r14     # 0x18fd0
movq (%r14), %rcx
leaq 0xb84e(%rip), %rdi      # 0x10033
pushq $0x31
popq %rsi
pushq $0x1
popq %rdx
callq 0x4430
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x4270
jmp 0x47b4
movq %rax, %rbx
leaq -0x2b0(%rbp), %rdi
callq 0xd2b2
movq %rbx, %rdi
callq 0x43d0
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseEnd(tmxparser::TmxMap*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TmxReturn _parseEnd(TmxMap* outMap, const std::string& tilesetPath)
{
	for (auto tileIt = outMap->tilesetCollection.begin(); tileIt != outMap->tilesetCollection.end(); ++tileIt)
		_parseEndHelper(tileIt->image, tilesetPath);

	for (auto tileIt = outMap->imageLayerCollection.begin(); tileIt != outMap->imageLayerCollection.end(); ++tileIt)
		_parseEndHelper(tileIt->image, tilesetPath);

	return TmxReturn::kSuccess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb0(%rdi), %r15
cmpq 0xb8(%r14), %r15
je 0x4ee4
leaq 0x68(%r15), %rdi
movq %rbx, %rsi
callq 0x4f16
addq $0x108, %r15            # imm = 0x108
jmp 0x4ec6
movq 0xf8(%r14), %r15
cmpq 0x100(%r14), %r15
je 0x4f09
leaq 0x70(%r15), %rdi
movq %rbx, %rsi
callq 0x4f16
addq $0xd8, %r15
jmp 0x4eeb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_updatePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string _updatePath(std::string path, const std::string& tilesetPath)
{
	auto pathSeperatorMissing = (path.find(PATH_SEPARATOR) == std::string::npos);
	auto pathSeperatorAltMissing = (path.find(PATH_SEPARATOR_ALT) == std::string::npos);

	if (pathSeperatorMissing && pathSeperatorAltMissing) // no path_seperator found --> relative path
	{
		std::string baseFilename = path.substr(path.find_last_of(PATH_SEPARATOR) + 1);

		/*
		 * here we find out what separator is used in tilesetPath and choose it
		 * if both (alternative and normal) separators are used, we always use the normal separator
		 **/
		auto seperatorThere = (tilesetPath.find(PATH_SEPARATOR) != std::string::npos);
		auto seperatorAltThere = (tilesetPath.find(PATH_SEPARATOR_ALT) != std::string::npos);
		auto tileSetPathSeparator = PATH_SEPARATOR;

		if (!seperatorThere && seperatorAltThere) // only alternative separator exists in tilesetPath --> choose it
			tileSetPathSeparator = PATH_SEPARATOR_ALT;

		return tilesetPath + tileSetPathSeparator + baseFilename;
	}

  return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xbe37(%rip), %r12      # 0x10de2
movq %rsi, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4460
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4460
andq %r13, %rax
cmpq $-0x1, %rax
je 0x4fde
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4290
jmp 0x5055
leaq 0xbdfd(%rip), %r12      # 0x10de2
pushq $-0x1
popq %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x41d0
leaq 0x1(%rax), %rdx
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x4220
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4460
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4460
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x68f9
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
movq %rbx, %rdi
callq 0x68d0
leaq -0x48(%rbp), %rdi
callq 0x4478
leaq -0x68(%rbp), %rdi
callq 0x4478
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4478
jmp 0x5078
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x4478
movq %rbx, %rdi
callq 0x43d0
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parsePropertyNode(tinyxml2::XMLElement*, std::unordered_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::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, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>*)
TmxReturn _parsePropertyNode(tinyxml2::XMLElement* element, TmxPropertyMap_t* outPropertyMap)
{
	if (element == NULL)
	{
		// ignore this, not everything requires properties
		return TmxReturn::kSuccess;
	}

	for (tinyxml2::XMLElement* child = element->FirstChildElement("property"); child != NULL; child = child->NextSiblingElement("property"))
	{
		if (strcmp(child->Name(), "property") == 0)
		{
			if (child->Attribute("name") != NULL && child->Attribute("value") != NULL)
			{
				(*outPropertyMap)[child->Attribute("name")] = child->Attribute("value");
			}
			else
			{
				return TmxReturn::kMalformedPropertyNode;
			}
		}
	}

	return TmxReturn::kSuccess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x38(%rbp)
testq %rdi, %rdi
je 0x5174
leaq 0xb1aa(%rip), %r15      # 0x10258
movq %r15, %rsi
callq 0xbae8
movq %rax, %r13
leaq 0xb1a6(%rip), %r14      # 0x10266
leaq -0x58(%rbp), %r12
testq %r13, %r13
je 0x5174
movq %r13, %rdi
callq 0xb914
movq %rax, %rdi
movq %r15, %rsi
callq 0x42e0
testl %eax, %eax
jne 0x5161
movq %r13, %rdi
leaq 0xb173(%rip), %rsi      # 0x10261
xorl %edx, %edx
callq 0xc8a0
testq %rax, %rax
je 0x5178
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xc8a0
testq %rax, %rax
je 0x5178
movq %r13, %rdi
movq %r14, %rbx
movq %r14, %rsi
xorl %edx, %edx
callq 0xc8a0
movq %rax, %r14
movq %r13, %rdi
leaq 0xb138(%rip), %rsi      # 0x10261
xorl %edx, %edx
callq 0xc8a0
movq %r12, %rdi
movq %rax, %rsi
leaq -0x29(%rbp), %rdx
callq 0x40d0
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x94e2
movq %rax, %rdi
movq %r14, %rsi
callq 0x4420
movq %r12, %rdi
callq 0x4478
movq %rbx, %r14
movq %r13, %rdi
movq %r15, %rsi
callq 0xbbb8
movq %rax, %r13
jmp 0x50c4
xorl %eax, %eax
jmp 0x517b
pushq $0x6
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4478
movq %rbx, %rdi
callq 0x43d0
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseLayerNode(tinyxml2::XMLElement*, std::vector<tmxparser::TmxTileset, std::allocator<tmxparser::TmxTileset>> const&, tmxparser::TmxLayer*)
TmxReturn _parseLayerNode(tinyxml2::XMLElement* element, const TmxTilesetCollection_t& tilesets, TmxLayer* outLayer)
{
	TmxReturn error = TmxReturn::kSuccess;

	outLayer->name = element->Attribute("name");
	if (element->Attribute("opacity"))
		outLayer->opacity = element->FloatAttribute("opacity");
	else
		outLayer->opacity = 1.f;
	if (element->Attribute("visible"))
		outLayer->visible = (element->IntAttribute("visible") == 1 ? true : false);
	else
		outLayer->visible = true;
	outLayer->width = element->UnsignedAttribute("width");
	outLayer->height = element->UnsignedAttribute("height");

	error = _parsePropertyNode(element->FirstChildElement("properties"), &outLayer->propertyMap);
	if (error)
	{
		LOGE("Error parsing layer property node...");
		return error;
	}

	// check data node and type
	tinyxml2::XMLElement* dataElement = element->FirstChildElement("data");
	if (dataElement != NULL)
	{
		error = _parseLayerDataNode(dataElement, tilesets, &outLayer->tiles);
	}
	else
	{
		LOGE("Layer missing data node...");
		return TmxReturn::kMissingDataNode;
	}

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xae7f(%rip), %rsi      # 0x10261
xorl %edx, %edx
callq 0xc8a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4420
leaq 0xafc2(%rip), %rsi      # 0x103bd
movq %r15, %rdi
xorl %edx, %edx
callq 0xc8a0
testq %rax, %rax
je 0x541b
leaq 0xafac(%rip), %rsi      # 0x103bd
movq %r15, %rdi
callq 0x6cb6
jmp 0x5423
movss 0xabe1(%rip), %xmm0     # 0x10004
movss %xmm0, 0x28(%rbx)
leaq 0xaf96(%rip), %rsi      # 0x103c5
movq %r15, %rdi
xorl %edx, %edx
callq 0xc8a0
testq %rax, %rax
je 0x5455
leaq 0xaf80(%rip), %rsi      # 0x103c5
movq %r15, %rdi
callq 0x6cfa
cmpl $0x1, %eax
sete %al
jmp 0x5457
movb $0x1, %al
movb %al, 0x2c(%rbx)
leaq 0xac9d(%rip), %rsi      # 0x100fe
movq %r15, %rdi
callq 0x6bc4
movl %eax, 0x20(%rbx)
leaq 0xac95(%rip), %rsi      # 0x10108
movq %r15, %rdi
callq 0x6bc4
movl %eax, 0x24(%rbx)
leaq 0xaca6(%rip), %rsi      # 0x1012b
movq %r15, %rdi
callq 0xbae8
leaq 0x30(%rbx), %rsi
movq %rax, %rdi
callq 0x5089
testl %eax, %eax
jne 0x54cb
leaq 0xaf60(%rip), %rsi      # 0x10404
movq %r15, %rdi
callq 0xbae8
testq %rax, %rax
je 0x54f7
addq $0x68, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6023
movl %eax, %r12d
movq 0x13afb(%rip), %rbx     # 0x18fd0
movq (%rbx), %rcx
leaq 0xaeee(%rip), %rdi      # 0x103cd
pushq $0x36
popq %rsi
pushq $0x1
popq %rdx
callq 0x4430
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x4270
jmp 0x5522
movq 0x13ad2(%rip), %rbx     # 0x18fd0
movq (%rbx), %rcx
leaq 0xaf01(%rip), %rdi      # 0x10409
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x4430
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x4270
pushq $0x4
popq %r12
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseImageNode(tinyxml2::XMLElement*, tmxparser::TmxImage*)
TmxReturn _parseImageNode(tinyxml2::XMLElement* element, TmxImage* outImage)
{
	CHECK_AND_RETRIEVE_REQ_ATTRIBUTE_STRING(element, "source", outImage->source);
	CHECK_AND_RETRIEVE_OPT_ATTRIBUTE_STRING(element, "format", outImage->format);
	CHECK_AND_RETRIEVE_OPT_ATTRIBUTE_STRING(element, "trans", outImage->transparentColor);

	outImage->width = element->UnsignedAttribute("width");
	outImage->height = element->UnsignedAttribute("height");

	return TmxReturn::kSuccess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa943(%rip), %rsi      # 0x1026c
xorl %edx, %edx
callq 0xc8a0
leaq 0x20(%rbx), %rdi
movq %rax, %rsi
callq 0x4420
cmpq $0x0, 0x28(%rbx)
je 0x59f0
leaq 0xa925(%rip), %rsi      # 0x10273
movq %r14, %rdi
xorl %edx, %edx
callq 0xc8a0
testq %rax, %rax
je 0x597b
leaq 0xa90f(%rip), %rsi      # 0x10273
movq %r14, %rdi
xorl %edx, %edx
callq 0xc8a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4420
jmp 0x5985
movq %rbx, %rdi
xorl %esi, %esi
callq 0x43a0
leaq 0xa8ee(%rip), %rsi      # 0x1027a
movq %r14, %rdi
xorl %edx, %edx
callq 0xc8a0
testq %rax, %rax
je 0x59ba
leaq 0xa8d8(%rip), %rsi      # 0x1027a
movq %r14, %rdi
xorl %edx, %edx
callq 0xc8a0
leaq 0x40(%rbx), %rdi
movq %rax, %rsi
callq 0x4420
jmp 0x59c5
leaq 0x40(%rbx), %rdi
xorl %esi, %esi
callq 0x43a0
leaq 0xa732(%rip), %rsi      # 0x100fe
movq %r14, %rdi
callq 0x6bc4
movl %eax, 0x60(%rbx)
leaq 0xa72a(%rip), %rsi      # 0x10108
movq %r14, %rdi
callq 0x6bc4
movl %eax, 0x64(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x135d9(%rip), %rbx     # 0x18fd0
movq (%rbx), %rdi
leaq 0xa6c7(%rip), %rsi      # 0x100c8
leaq 0xa864(%rip), %rdx      # 0x1026c
xorl %eax, %eax
callq 0x42f0
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x4270
pushq $0x2
popq %rax
jmp 0x59eb
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseOffsetNode(tinyxml2::XMLElement*, tmxparser::TmxOffset*)
tmxparser::TmxReturn _parseOffsetNode(tinyxml2::XMLElement* element, TmxOffset* offset)
{
	TmxReturn error = TmxReturn::kSuccess;

	offset->x = 0;
	offset->y = 0;

	if (element->Attribute("x"))
	{
		offset->x = element->IntAttribute("x");
	}

	if (element->Attribute("y"))
	{
		offset->y = element->IntAttribute("y");
	}

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
andq $0x0, (%rsi)
leaq 0xab37(%rip), %rsi      # 0x108cd
xorl %edx, %edx
callq 0xc8a0
testq %rax, %rax
je 0x5db3
leaq 0xab24(%rip), %rsi      # 0x108cd
movq %r14, %rdi
callq 0x6cfa
movl %eax, (%rbx)
leaq 0xa609(%rip), %rsi      # 0x103c3
movq %r14, %rdi
xorl %edx, %edx
callq 0xc8a0
testq %rax, %rax
je 0x5ddb
leaq 0xa5f3(%rip), %rsi      # 0x103c3
movq %r14, %rdi
callq 0x6cfa
movl %eax, 0x4(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseTileDefinitionNode(tinyxml2::XMLElement*, tmxparser::TmxTileDefinition*)
TmxReturn _parseTileDefinitionNode(tinyxml2::XMLElement* element, TmxTileDefinition* outTileDefinition)
{
	TmxReturn error = TmxReturn::kSuccess;

	outTileDefinition->id = element->UnsignedAttribute("id");
	error = _parsePropertyNode(element->FirstChildElement("properties"), &outTileDefinition->propertyMap);
	if (error)
	{
		return error;
	}

	if (element->FirstChildElement("animation") != NULL)
	{
		error = _parseTileAnimationNode(element->FirstChildElement("animation"), &outTileDefinition->animations);
	}

	for (tinyxml2::XMLElement* child = element->FirstChildElement("objectgroup"); child != NULL; child = child->NextSiblingElement("objectgroup"))
	{
		TmxObjectGroup group;
		error = _parseObjectGroupNode(child, &group);
		if (error)
		{
			LOGE("Error processing objectgroup node...");
			return error;
		}

		outTileDefinition->objectgroups.push_back(group);
	}

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0xa5b7(%rip), %rsi      # 0x103ba
callq 0x6bc4
movl %eax, (%r15)
leaq 0xa319(%rip), %rsi      # 0x1012b
movq %r12, %rdi
callq 0xbae8
leaq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x5089
movl %eax, %r14d
testl %eax, %eax
jne 0x5f72
leaq 0xa565(%rip), %rsi      # 0x1039d
movq %r12, %rdi
callq 0xbae8
testq %rax, %rax
je 0x5e60
leaq 0xa551(%rip), %rsi      # 0x1039d
movq %r12, %rdi
callq 0xbae8
leaq 0x40(%r15), %rsi
movq %rax, %rdi
callq 0x5f9e
leaq 0xa370(%rip), %rsi      # 0x101d7
movq %r12, %rdi
callq 0xbae8
movq %rax, %r12
leaq -0xc0(%rbp), %rbx
addq $0x58, %r15
movq %r15, -0x38(%rbp)
xorl %r14d, %r14d
leaq -0xd0(%rbp), %r13
testq %r12, %r12
je 0x5f72
movq %rbx, -0xd0(%rbp)
andq $0x0, -0xc8(%rbp)
movb %r14b, -0xc0(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
andq $0x0, -0xa8(%rbp)
movb %r14b, -0xa0(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x88(%rbp)
movq $0x1, -0x80(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movl $0x3f800000, -0x68(%rbp) # imm = 0x3F800000
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
andq $0x0, 0x80(%rbx)
movq %r12, %rdi
movq %r13, %rsi
callq 0x552e
movl %eax, %r15d
testl %eax, %eax
jne 0x5f3a
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x6aa8
movq %r13, %rdi
callq 0x6ae6
testl %r15d, %r15d
jne 0x5f6e
movq %r12, %rdi
leaq 0xa2aa(%rip), %rsi      # 0x101d7
callq 0xbbb8
movq %rax, %r12
jmp 0x5e8b
movq 0x1308f(%rip), %rax     # 0x18fd0
movq (%rax), %rcx
leaq 0xa298(%rip), %rdi      # 0x101e3
pushq $0x36
popq %rsi
pushq $0x1
popq %rdx
callq 0x4430
movq 0x13073(%rip), %rax     # 0x18fd0
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x4270
movl %r15d, -0x2c(%rbp)
jmp 0x5f16
movl -0x2c(%rbp), %r14d
movl %r14d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x6ae6
movq %rbx, %rdi
callq 0x43d0
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseTileAnimationNode(tinyxml2::XMLElement*, std::vector<tmxparser::TmxAnimationFrame, std::allocator<tmxparser::TmxAnimationFrame>>*)
TmxReturn _parseTileAnimationNode(tinyxml2::XMLElement* element, TmxAnimationFrameCollection_t* outAnimationCollection)
{
	for (tinyxml2::XMLElement* child = element->FirstChildElement("frame"); child != NULL; child = child->NextSiblingElement("frame"))
	{
		TmxAnimationFrame frame;
		frame.duration = child->FloatAttribute("duration");
		frame.tileId = child->UnsignedAttribute("tileid");

		outAnimationCollection->push_back(frame);
	}

	return kSuccess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xa3f1(%rip), %rsi      # 0x103a7
callq 0xbae8
movq %rax, %r14
leaq 0xa3e8(%rip), %r15      # 0x103ad
leaq 0xa3ea(%rip), %r12      # 0x103b6
leaq -0x30(%rbp), %r13
testq %r14, %r14
je 0x6012
movq %r14, %rdi
movq %r15, %rsi
callq 0x6cb6
movss %xmm0, -0x2c(%rbp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x6bc4
movl %eax, -0x30(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6cd6
movq %r14, %rdi
leaq 0xa39f(%rip), %rsi      # 0x103a7
callq 0xbbb8
movq %rax, %r14
jmp 0x5fd0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseLayerXmlTileNode(tinyxml2::XMLElement*, std::vector<tmxparser::TmxTileset, std::allocator<tmxparser::TmxTileset>> const&, tmxparser::TmxLayerTile*)
TmxReturn _parseLayerXmlTileNode(tinyxml2::XMLElement* element, const TmxTilesetCollection_t& tilesets, TmxLayerTile* outTile)
{
	TmxReturn error = TmxReturn::kSuccess;

	unsigned int gid = element->UnsignedAttribute("gid");

	unsigned int flipXFlag = 0x80000000;
	unsigned int flipYFlag = 0x40000000;
	unsigned int flipDiagonalFlag = 0x20000000;

	outTile->flipX = (gid & flipXFlag ? true : false);
	outTile->flipY = (gid & flipYFlag ? true : false);
	outTile->flipDiagonal = (gid & flipDiagonalFlag ? true : false);
	outTile->gid = (gid & ~(flipXFlag | flipYFlag | flipDiagonalFlag));

	return _calculateTileIndices(tilesets, outTile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x9fa4(%rip), %rsi      # 0x1036a
callq 0x6bc4
movl %eax, %ecx
shrl $0x1f, %ecx
movb %cl, 0xc(%rbx)
movl %eax, %ecx
shrl $0x1e, %ecx
andb $0x1, %cl
movb %cl, 0xd(%rbx)
movl %eax, %ecx
shrl $0x1d, %ecx
andb $0x1, %cl
movb %cl, 0xe(%rbx)
andl $0x1fffffff, %eax       # imm = 0x1FFFFFFF
movl %eax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x63ff
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::calculateTileCoordinatesUV(tmxparser::TmxTileset const&, unsigned int, float, bool, tmxparser::TmxRect&)
TmxReturn calculateTileCoordinatesUV(const TmxTileset& tileset,  unsigned int tileFlatIndex, float pixelCorrection, bool flipY, TmxRect& outRect)
{
	if (tileFlatIndex >= tileset.colCount * tileset.rowCount)
	{
		return TmxReturn::kInvalidTileIndex;
	}

	TileId_t xIndex = tileFlatIndex % tileset.colCount;
	TileId_t yIndex = tileFlatIndex / tileset.colCount;

	unsigned int widthDelta = tileset.tileSpacingInImage + tileset.tileMarginInImage*xIndex;
	unsigned int heightDelta = tileset.tileSpacingInImage + tileset.tileMarginInImage*yIndex;

	float u = (float)((xIndex * tileset.tileWidth) + widthDelta + pixelCorrection) / (float)tileset.image.width;
	float v = (float)((yIndex * tileset.tileHeight) + heightDelta + pixelCorrection) / (float)tileset.image.height;

	float u2 = (float)((( (xIndex+1) * tileset.tileWidth) + widthDelta) - pixelCorrection) / (float)tileset.image.width;
	float v2 = (float)((( (yIndex+1) * tileset.tileHeight) + heightDelta) - pixelCorrection) / (float)tileset.image.height;

	if (flipY)
	{
		float tmpV = v;
		v = 1.f - v2;
		v2 = 1.f - tmpV;
	}

	outRect.u = u;
	outRect.v = v;
	outRect.u2 = u2;
	outRect.v2 = v2;

	return kSuccess;
}

// Assembly:
movl 0x64(%rdi), %r9d
movl 0x60(%rdi), %eax
imull %r9d, %eax
cmpl %esi, %eax
jbe 0x68ca
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %r8d
movl %esi, %eax
xorl %edx, %edx
divl %r9d
movl %eax, %esi
xorl %eax, %eax
movl 0x50(%rdi), %r11d
movl 0x54(%rdi), %r9d
movl %r9d, %r10d
imull %edx, %r10d
addl %r11d, %r10d
imull %esi, %r9d
addl %r11d, %r9d
movl 0x48(%rdi), %r11d
movl %r11d, %ebx
imull %edx, %ebx
addl %r10d, %ebx
cvtsi2ss %rbx, %xmm1
movl 0xc8(%rdi), %ebx
cvtsi2ss %rbx, %xmm4
movl 0x4c(%rdi), %ebx
addss %xmm0, %xmm1
movl %ebx, %r14d
imull %esi, %r14d
addl %r9d, %r14d
cvtsi2ss %r14, %xmm2
movl 0xcc(%rdi), %edi
cvtsi2ss %rdi, %xmm5
divss %xmm4, %xmm1
addss %xmm0, %xmm2
incl %edx
imull %r11d, %edx
addl %r10d, %edx
cvtsi2ss %rdx, %xmm3
subss %xmm0, %xmm3
divss %xmm4, %xmm3
incl %esi
imull %ebx, %esi
addl %r9d, %esi
cvtsi2ss %rsi, %xmm4
divss %xmm5, %xmm2
subss %xmm0, %xmm4
divss %xmm5, %xmm4
testb %r8b, %r8b
je 0x68b2
movss 0x9763(%rip), %xmm0     # 0x10004
movaps %xmm0, %xmm5
subss %xmm4, %xmm5
subss %xmm2, %xmm0
movaps %xmm5, %xmm2
movaps %xmm0, %xmm4
movss %xmm1, (%rcx)
movss %xmm2, 0x4(%rcx)
movss %xmm3, 0x8(%rcx)
movss %xmm4, 0xc(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
movl $0x7, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::XMLElement::QueryUnsignedAttribute(char const*, unsigned int*) const
XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const	{
        const XMLAttribute* a = FindAttribute( name );
        if ( !a ) {
            return XML_NO_ATTRIBUTE;
        }
        return a->QueryUnsignedValue( value );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0xc85c
testq %rax, %rax
je 0x6956
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc542
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::XMLElement::QueryFloatAttribute(char const*, float*) const
XMLError QueryFloatAttribute( const char* name, float* value ) const			{
        const XMLAttribute* a = FindAttribute( name );
        if ( !a ) {
            return XML_NO_ATTRIBUTE;
        }
        return a->QueryFloatValue( value );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0xc85c
testq %rax, %rax
je 0x6e16
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc59a
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::XMLElement::QueryBoolAttribute(char const*, bool*) const
XMLError QueryBoolAttribute( const char* name, bool* value ) const				{
        const XMLAttribute* a = FindAttribute( name );
        if ( !a ) {
            return XML_NO_ATTRIBUTE;
        }
        return a->QueryBoolValue( value );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0xc85c
testq %rax, %rax
je 0x6e44
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc56e
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::XMLElement::QueryIntAttribute(char const*, int*) const
XMLError QueryIntAttribute( const char* name, int* value ) const				{
        const XMLAttribute* a = FindAttribute( name );
        if ( !a ) {
            return XML_NO_ATTRIBUTE;
        }
        return a->QueryIntValue( value );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0xc85c
testq %rax, %rax
je 0x834a
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc516
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/main.cpp
// Function: printObjectGroups(int, std::vector<tmxparser::TmxObjectGroup, std::allocator<tmxparser::TmxObjectGroup>> const&)
void printObjectGroups(int depth, const tmxparser::TmxObjectGroupCollection_t& collection)
{
	int nextdepth = depth +1;

	for (auto it = collection.begin(); it != collection.end(); ++it)
	{
		printf_depth(depth, "%s", "<objectgroup>");

		printf_depth(nextdepth, "Name: %s", it->name.c_str());
		printf_depth(nextdepth, "Color: %s", it->color.c_str());
		printf_depth(nextdepth, "Opacity: %f", it->opacity);
		printf_depth(nextdepth, "Visible: %u", it->visible);
		printProperties(nextdepth, it->propertyMap);
		printObjects(nextdepth, it->objects);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r14
leal (%rdi,%rdi,4), %eax
movl %eax, -0x2c(%rbp)
leal (%rdi,%rdi,4), %r15d
addl $0x5, %r15d
movl %edi, %r12d
incl %r12d
leaq 0x641e(%rip), %r13      # 0x1090e
cmpq 0x8(%rbx), %r14
je 0xa59e
leaq 0x60db(%rip), %rdi      # 0x105dc
movl -0x2c(%rbp), %esi
movq %r13, %rdx
leaq 0x61a8(%rip), %rcx      # 0x106b6
xorl %eax, %eax
callq 0x4050
movq (%r14), %rcx
leaq 0x60e6(%rip), %rdi      # 0x10605
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
movq 0x20(%r14), %rcx
leaq 0x618d(%rip), %rdi      # 0x106c4
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
cvtss2sd 0x40(%r14), %xmm0
leaq 0x6182(%rip), %rdi      # 0x106d3
movl %r15d, %esi
movq %r13, %rdx
movb $0x1, %al
callq 0x4050
movzbl 0x44(%r14), %ecx
leaq 0x617a(%rip), %rdi      # 0x106e4
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
leaq 0x48(%r14), %rsi
movl %r12d, %edi
callq 0xa268
leaq 0x80(%r14), %rsi
movl %r12d, %edi
callq 0xa2e1
addq $0x98, %r14
jmp 0xa4f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/main.cpp
// Function: printImageData(int, tmxparser::TmxImage const&)
void printImageData(int depth, const tmxparser::TmxImage& tmximage)
{
	printf_depth(depth, "%s", "<image>");

	depth = depth +1;
	printf_depth(depth, "Source: %s", tmximage.source.c_str());
	printf_depth(depth, "Format: %s", tmximage.format.c_str());
	printf_depth(depth, "Width: %u", tmximage.width);
	printf_depth(depth, "Height: %u", tmximage.height);
	printf_depth(depth, "TransparentColor: %s", tmximage.transparentColor.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r15d
leal (%r15,%r15,4), %esi
leaq 0x6014(%rip), %rdi      # 0x105dc
leaq 0x633f(%rip), %r14      # 0x1090e
leaq 0x611f(%rip), %rcx      # 0x106f5
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
leal (%r15,%r15,4), %r15d
addl $0x5, %r15d
movq 0x20(%rbx), %rcx
leaq 0x610a(%rip), %rdi      # 0x106fd
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
movq (%rbx), %rcx
leaq 0x6103(%rip), %rdi      # 0x1070d
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x60(%rbx), %ecx
leaq 0x60fc(%rip), %rdi      # 0x1071d
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x64(%rbx), %ecx
leaq 0x60f4(%rip), %rdi      # 0x1072c
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
movq 0x40(%rbx), %rcx
leaq 0x60ec(%rip), %rdi      # 0x1073c
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4050
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/main.cpp
// Function: printTileDefinition(int, std::unordered_map<unsigned int, tmxparser::TmxTileDefinition, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, tmxparser::TmxTileDefinition>>> const&)
void printTileDefinition(int depth, const tmxparser::TmxTileDefinitionMap_t& map)
{
	for (auto it = map.begin(); it != map.end(); ++it)
	{
		printf_depth(depth, "%s", "<tile>");
		printf_depth(depth+1, "Id: %u", it->second.id);

		printProperties(depth+1, it->second.propertyMap);

		// animations
		printf_depth(depth+1, "%s", "<animation>");
		depth+=2;
		for (auto animIt = it->second.animations.begin(); animIt != it->second.animations.end(); ++animIt)
		{
			printf_depth(depth, "<frame tileId=%u duration=%f>", animIt->tileId, animIt->duration);
		}
		depth-=2;

		printObjectGroups(depth+1, it->second.objectgroups);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
addq $0x10, %rbx
leal (%rdi,%rdi,4), %eax
movl %eax, -0x34(%rbp)
leal (%rdi,%rdi,4), %eax
addl $0x5, %eax
movl %eax, -0x30(%rbp)
leal (%rdi,%rdi,4), %r12d
addl $0xa, %r12d
movl %edi, %eax
incl %eax
movl %eax, -0x2c(%rbp)
leaq 0x626a(%rip), %r14      # 0x1090e
leaq 0x60ca(%rip), %r15      # 0x10775
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xa74f
leaq 0x5f1e(%rip), %rdi      # 0x105dc
movl -0x34(%rbp), %esi
movq %r14, %rdx
leaq 0x608b(%rip), %rcx      # 0x10756
xorl %eax, %eax
callq 0x4050
movl 0x10(%rbx), %ecx
leaq 0x6081(%rip), %rdi      # 0x1075d
movl -0x30(%rbp), %r13d
movl %r13d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
leaq 0x18(%rbx), %rsi
movl -0x2c(%rbp), %edi
callq 0xa268
leaq 0x5edc(%rip), %rdi      # 0x105dc
movl %r13d, %esi
movq %r14, %rdx
leaq 0x605c(%rip), %rcx      # 0x10769
xorl %eax, %eax
callq 0x4050
movq 0x50(%rbx), %r13
cmpq 0x58(%rbx), %r13
je 0xa73e
movl (%r13), %ecx
cvtss2sd 0x4(%r13), %xmm0
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
movb $0x1, %al
callq 0x4050
addq $0x8, %r13
jmp 0xa718
leaq 0x68(%rbx), %rsi
movl -0x2c(%rbp), %edi
callq 0xa4c1
jmp 0xa6ab
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/main.cpp
// Function: printTilesets(int, std::vector<tmxparser::TmxTileset, std::allocator<tmxparser::TmxTileset>> const&)
void printTilesets(int depth, const tmxparser::TmxTilesetCollection_t& collection)
{
	for (auto it = collection.begin(); it != collection.end(); ++it)
	{
		printf_depth(depth, "%s", "<tileset>");

		int nextdepth = depth + 1;

		printf_depth(nextdepth, "Name: %s", (*it).name.c_str());
		printf_depth(nextdepth, "FirstGid: %u", (*it).firstgid);
		printf_depth(nextdepth, "Width: %u", (*it).tileWidth);
		printf_depth(nextdepth, "Height: %u", (*it).tileHeight);
		printf_depth(nextdepth, "MarginImage: %u", (*it).tileMarginInImage);
		printf_depth(nextdepth, "SpaceImage: %u", (*it).tileSpacingInImage);
		printf_depth(nextdepth, "rowCount: %u", (*it).colCount);
		printf_depth(nextdepth, "colCount: %u", (*it).rowCount);
		printImageData(nextdepth, (*it).image);
		printTileDefinition(nextdepth, (*it).tileDefinitions);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r14
leal (%rdi,%rdi,4), %eax
movl %eax, -0x2c(%rbp)
leal (%rdi,%rdi,4), %r15d
addl $0x5, %r15d
movl %edi, %r12d
incl %r12d
leaq 0x6181(%rip), %r13      # 0x1090e
cmpq 0x8(%rbx), %r14
je 0xa899
leaq 0x5e3e(%rip), %rdi      # 0x105dc
movl -0x2c(%rbp), %esi
movq %r13, %rdx
leaq 0x5fed(%rip), %rcx      # 0x10798
xorl %eax, %eax
callq 0x4050
movq 0x28(%r14), %rcx
leaq 0x5e48(%rip), %rdi      # 0x10605
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x20(%r14), %ecx
leaq 0x5fcd(%rip), %rdi      # 0x107a2
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x48(%r14), %ecx
leaq 0x5f30(%rip), %rdi      # 0x1071d
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x4c(%r14), %ecx
leaq 0x5f27(%rip), %rdi      # 0x1072c
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x54(%r14), %ecx
leaq 0x5f97(%rip), %rdi      # 0x107b4
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x50(%r14), %ecx
leaq 0x5f94(%rip), %rdi      # 0x107c9
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x64(%r14), %ecx
leaq 0x5f90(%rip), %rdi      # 0x107dd
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x60(%r14), %ecx
leaq 0x5f8a(%rip), %rdi      # 0x107ef
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
leaq 0x68(%r14), %rsi
movl %r12d, %edi
callq 0xa5ad
leaq 0xd0(%r14), %rsi
movl %r12d, %edi
callq 0xa667
addq $0x108, %r14            # imm = 0x108
jmp 0xa78d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/main.cpp
// Function: printLayerTiles(int, std::vector<tmxparser::TmxLayerTile, std::allocator<tmxparser::TmxLayerTile>> const&)
void printLayerTiles(int depth, const tmxparser::TmxLayerTileCollection_t& collection)
{
	for (auto it = collection.begin(); it != collection.end(); ++it)
	{
		printf_depth(depth, "%s", "<tile>");

		int nextdepth = depth + 1;

		printf_depth(nextdepth, "Gid: %u", it->gid);
		printf_depth(nextdepth, "tilesetIndex: %u", it->tilesetIndex);
		printf_depth(nextdepth, "tileFlatIndex: %u", it->tileFlatIndex);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r12
leal (%rdi,%rdi,4), %r14d
leal (%rdi,%rdi,4), %r15d
addl $0x5, %r15d
leaq 0x603f(%rip), %r13      # 0x1090e
cmpq 0x8(%rbx), %r12
je 0xa940
leaq 0x5d00(%rip), %rdi      # 0x105dc
movl %r14d, %esi
movq %r13, %rdx
leaq 0x5e6d(%rip), %rcx      # 0x10756
xorl %eax, %eax
callq 0x4050
movl (%r12), %ecx
leaq 0x5f06(%rip), %rdi      # 0x10801
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x4(%r12), %ecx
leaq 0x5efa(%rip), %rdi      # 0x1080e
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x8(%r12), %ecx
leaq 0x5ef7(%rip), %rdi      # 0x10824
movl %r15d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
addq $0x10, %r12
jmp 0xa8cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/main.cpp
// Function: printLayers(int, std::vector<tmxparser::TmxLayer, std::allocator<tmxparser::TmxLayer>> const&)
void printLayers(int depth, const tmxparser::TmxLayerCollection_t& collection)
{
	for (auto it = collection.begin(); it != collection.end(); ++it)
	{
		printf_depth(depth, "%s", "<layer>");

		int nextdepth = depth + 1;

		printf_depth(nextdepth, "Name: %s", it->name.c_str());
		printf_depth(nextdepth, "Width: %u", (*it).width);
		printf_depth(nextdepth, "Height: %u", (*it).height);
		printf_depth(nextdepth, "Opacity: %f", (*it).opacity);
		printf_depth(nextdepth, "Visible: %u", (*it).visible);
		printProperties(nextdepth+1, it->propertyMap);
		printLayerTiles(nextdepth+1, it->tiles);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movq (%rsi), %r15
leal (%r14,%r14,4), %eax
movl %eax, -0x2c(%rbp)
leal (%r14,%r14,4), %r12d
addl $0x5, %r12d
addl $0x2, %r14d
leaq 0x5f8e(%rip), %r13      # 0x1090e
cmpq 0x8(%rbx), %r15
je 0xaa40
leaq 0x5c4b(%rip), %rdi      # 0x105dc
movl -0x2c(%rbp), %esi
movq %r13, %rdx
leaq 0x5e9d(%rip), %rcx      # 0x1083b
xorl %eax, %eax
callq 0x4050
movq (%r15), %rcx
leaq 0x5c56(%rip), %rdi      # 0x10605
movl %r12d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x20(%r15), %ecx
leaq 0x5d56(%rip), %rdi      # 0x1071d
movl %r12d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x24(%r15), %ecx
leaq 0x5d4d(%rip), %rdi      # 0x1072c
movl %r12d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
cvtss2sd 0x28(%r15), %xmm0
leaq 0x5cda(%rip), %rdi      # 0x106d3
movl %r12d, %esi
movq %r13, %rdx
movb $0x1, %al
callq 0x4050
movzbl 0x2c(%r15), %ecx
leaq 0x5cd2(%rip), %rdi      # 0x106e4
movl %r12d, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4050
leaq 0x30(%r15), %rsi
movl %r14d, %edi
callq 0xa268
leaq 0x68(%r15), %rsi
movl %r14d, %edi
callq 0xa8a8
subq $-0x80, %r15
jmp 0xa980
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/main.cpp
// Function: printTmxMapData(tmxparser::TmxMap const*)
void printTmxMapData(const tmxparser::TmxMap* map)
{
	int depth = 0;

	printf_depth(0, "%s", "<map>");
	depth = 1;
	printf_depth(depth, "Version: %s", map->version.c_str());
	printf_depth(depth, "Orientation: %d", map->orientation);
	printf_depth(depth, "Width: %u", map->width);
	printf_depth(depth, "Height: %u", map->height);
	printf_depth(depth, "TileWidth: %u", map->tileWidth);
	printf_depth(depth, "TileHeight: %u", map->tileHeight);
	printf_depth(depth, "BackgroundColor: %s", map->backgroundColor.c_str());
	printProperties(depth+1, map->propertyMap);
	printTilesets(depth+1, map->tilesetCollection);
	printLayers(depth+1, map->layerCollection);
	printObjectGroups(depth+1, map->objectGroupCollection);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5b79(%rip), %rdi      # 0x105dc
leaq 0x5ea4(%rip), %r14      # 0x1090e
leaq 0x5dd2(%rip), %rcx      # 0x10843
xorl %esi, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
movq (%rbx), %rcx
leaq 0x5dc2(%rip), %rdi      # 0x10849
pushq $0x5
popq %r15
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x20(%rbx), %ecx
leaq 0x5db8(%rip), %rdi      # 0x1085a
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x24(%rbx), %ecx
leaq 0x5c64(%rip), %rdi      # 0x1071d
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x28(%rbx), %ecx
leaq 0x5c5c(%rip), %rdi      # 0x1072c
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x2c(%rbx), %ecx
leaq 0x5d88(%rip), %rdi      # 0x1086f
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
movl 0x30(%rbx), %ecx
leaq 0x5d84(%rip), %rdi      # 0x10882
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
movq 0x38(%rbx), %rcx
leaq 0x5d80(%rip), %rdi      # 0x10896
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4050
leaq 0x78(%rbx), %rsi
pushq $0x2
popq %r14
movl %r14d, %edi
callq 0xa268
leaq 0xb0(%rbx), %rsi
movl %r14d, %edi
callq 0xa75e
leaq 0xc8(%rbx), %rsi
movl %r14d, %edi
callq 0xa94f
addq $0xe0, %rbx
movl %r14d, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa4c1
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::StrPair::Reset()
void StrPair::Reset()
{
    if ( _flags & NEEDS_DELETE ) {
        delete [] _start;
    }
    _flags = 0;
    _start = 0;
    _end = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x2, 0x1(%rdi)
je 0xae97
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xae97
callq 0x4280
andl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::StrPair::TransferTo(tinyxml2::StrPair*)
void StrPair::TransferTo( StrPair* other )
{
    if ( this == other ) {
        return;
    }
    // This in effect implements the assignment operator by "moving"
    // ownership (as in auto_ptr).

    TIXMLASSERT( other->_flags == 0 );
    TIXMLASSERT( other->_start == 0 );
    TIXMLASSERT( other->_end == 0 );

    other->Reset();

    other->_flags = _flags;
    other->_start = _start;
    other->_end = _end;

    _flags = 0;
    _start = 0;
    _end = 0;
}

// Assembly:
cmpq %rsi, %rdi
je 0xaee5
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xae7a
movl (%rbx), %eax
movl %eax, (%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
andl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::StrPair::SetStr(char const*, int)
void StrPair::SetStr( const char* str, int flags )
{
    Reset();
    size_t len = strlen( str );
    _start = new char[ len+1 ];
    memcpy( _start, str, len+1 );
    _end = _start + len;
    _flags = flags | NEEDS_DELETE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
callq 0xae7a
movq %r14, %rdi
callq 0x40f0
movq %rax, %r12
leaq 0x1(%rax), %r13
movq %r13, %rdi
callq 0x4040
movq %rax, %r14
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq -0x30(%rbp), %rsi
movq %r13, %rdx
callq 0x4190
addq %r12, %r14
movq %r14, 0x10(%r15)
orl $0x200, %ebx            # imm = 0x200
movl %ebx, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::StrPair::ParseText(char*, char const*, int)
char* StrPair::ParseText( char* p, const char* endTag, int strFlags )
{
    TIXMLASSERT( endTag && *endTag );

    char* start = p;
    char  endChar = *endTag;
    size_t length = strlen( endTag );

    // Inner loop of text parsing.
    while ( *p ) {
        if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
            Set( start, p, strFlags );
            return p + length;
        }
        ++p;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
movb (%rdx), %bl
movq %rdx, %rdi
callq 0x40f0
movq %rax, %r14
xorl %r12d, %r12d
movq %r15, -0x40(%rbp)
movb (%r15), %al
testb %al, %al
je 0xafbf
cmpb %bl, %al
jne 0xafa1
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x4120
testl %eax, %eax
je 0xafa6
incq %r15
jmp 0xaf84
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %r15, %rdx
movl -0x2c(%rbp), %ecx
callq 0xe2be
addq %r15, %r14
movq %r14, %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop