LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: errantlinguist[P]Forecast/include/forecast_io/parsers/../../json/JsonArrayParser.hpp
// Function: json::JsonArrayParser<forecast_io::parsers::NotifyingAlertParser>::parse(json_object* const&)
virtual void parse(json_object* const& pJsonObj)
	{
		const int arrayLength = json_object_array_length(pJsonObj);
		for(int i = 0; i < arrayLength; ++i)
		{
			json_object* const& arrayElement = json_object_array_get_idx(
												   pJsonObj, i);
			handleArrayElement(arrayElement);
		}

		finishParse();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xa380
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4932b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x18(%rbp), %rsi
callq 0xa700
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x492ee
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: errantlinguist[P]Forecast/src/forecast_io/parsers/DataPointAttributeDefaultNameMapHolder.cpp
// Function: forecast_io::parsers::DataPointAttributeDefaultNameMapHolder::createInstance[abi:cxx11]()
std::unique_ptr<DataPointAttributeNameMap> DataPointAttributeDefaultNameMapHolder::createInstance()
{
	std::unique_ptr<DataPointAttributeNameMap> result(
			new DataPointAttributeNameMap(
					DataPointAttribute::DataPointAttribute_COUNT));
	insertDefaultAttributeNames(*result);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movl $0x38, %edi
callq 0xa140
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movb $0x1, -0x1d(%rbp)
leaq -0xc(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4dbe0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %r8
movl $0x20, %esi
leaq -0xa(%rbp), %rdx
leaq -0xb(%rbp), %rcx
callq 0x4dc00
jmp 0x4c49a
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
movb $0x0, -0x1d(%rbp)
callq 0x4dc40
leaq -0xc(%rbp), %rdi
callq 0x4dc70
movq -0x48(%rbp), %rdi
callq 0x4dc90
movq %rax, -0x50(%rbp)
jmp 0x4c4c3
movq -0x50(%rbp), %rdi
callq 0x4c540
jmp 0x4c4ce
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x4c527
jmp 0x4c51e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x4dc70
testb $0x1, -0x1d(%rbp)
jne 0x4c4f7
jmp 0x4c505
movq -0x38(%rbp), %rdi
movl $0x38, %esi
callq 0xa0f0
jmp 0x4c531
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4db70
jmp 0x4c531
movq -0x48(%rbp), %rdi
callq 0x4db70
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xa520
nopw (%rax,%rax)
// File: errantlinguist[P]Forecast/src/forecast_io/parsers/FlagsAttributeDefaultNameMapHolder.cpp
// Function: forecast_io::parsers::FlagsAttributeDefaultNameMapHolder::createInstance[abi:cxx11]()
std::unique_ptr<FlagsAttributeNameMap> FlagsAttributeDefaultNameMapHolder::createInstance()
{
	std::unique_ptr<FlagsAttributeNameMap> result(
			new FlagsAttributeNameMap(
					FlagsAttribute::FlagsAttribute_COUNT));
	insertDefaultAttributeNames(*result);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movl $0x38, %edi
callq 0xa140
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movb $0x1, -0x1d(%rbp)
leaq -0xc(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4fa60
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %r8
movl $0x4, %esi
leaq -0xa(%rbp), %rdx
leaq -0xb(%rbp), %rcx
callq 0x4fa80
jmp 0x4f68a
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
movb $0x0, -0x1d(%rbp)
callq 0x4fac0
leaq -0xc(%rbp), %rdi
callq 0x4faf0
movq -0x48(%rbp), %rdi
callq 0x4fb10
movq %rax, -0x50(%rbp)
jmp 0x4f6b3
movq -0x50(%rbp), %rdi
callq 0x4f730
jmp 0x4f6be
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x4f717
jmp 0x4f70e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x4faf0
testb $0x1, -0x1d(%rbp)
jne 0x4f6e7
jmp 0x4f6f5
movq -0x38(%rbp), %rdi
movl $0x38, %esi
callq 0xa0f0
jmp 0x4f721
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4f9f0
jmp 0x4f721
movq -0x48(%rbp), %rdi
callq 0x4f9f0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xa520
nopw (%rax,%rax)
// File: errantlinguist[P]Forecast/src/forecast_io/parsers/FlagsFactoryParser.cpp
// Function: forecast_io::parsers::FlagsFactoryParser::parse(json_object* const&)
void FlagsFactoryParser::parse(json_object* const & pJsonObj)
{
	NotifyingFlagParser::parse(pJsonObj);
	Flags flags = pFactory->create();

	for (listeners::FlagsListener* const & pFlagsListener : getFlagsListeners())
	{
		pFlagsListener->notifyFlags(flags);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x51800
movq -0xd8(%rbp), %rax
movq 0xe8(%rax), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x98(%rbp), %rdi
callq *%rax
movq -0xd8(%rbp), %rdi
callq 0x51940
movq %rax, -0xd0(%rbp)
jmp 0x5167a
movq -0xd0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x51960
movq %rax, -0xb8(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x51990
movq %rax, -0xc0(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x519c0
testb $0x1, %al
jne 0x516c7
jmp 0x51726
leaq -0xb8(%rbp), %rdi
callq 0x519f0
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x98(%rbp), %rsi
callq *%rax
jmp 0x516f6
jmp 0x516f8
leaq -0xb8(%rbp), %rdi
callq 0x51a20
jmp 0x516ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xe3c0
jmp 0x5173b
leaq -0x98(%rbp), %rdi
callq 0xe3c0
addq $0xe0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0xa520
nopw (%rax,%rax)
// File: errantlinguist[P]Forecast/include/forecast_io/parsers/../../json/AbstractJsonStateMapParser.hpp
// Function: json::AbstractJsonStateMapParser<forecast_io::parsers::FlagsAttribute>::parse(json_object* const&)
void parse(json_object* const & pJsonObj)
	{
		// Parse JSON data values
		json_object_object_foreach(pJsonObj, key, value)
		{
			parseAttribute(key, value);
		}

		finishParse();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xa170
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5187b
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x51883
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0x51883
movq -0x78(%rbp), %rax
cmpq $0x0, %rax
je 0x5191f
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xa770
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0xdcb0
jmp 0x518bf
movq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x53b10
jmp 0x518d2
leaq -0x50(%rbp), %rdi
callq 0xa978
leaq -0x51(%rbp), %rdi
callq 0xa960
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x51847
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x51914
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa978
leaq -0x51(%rbp), %rdi
callq 0xa960
jmp 0x51932
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xa520
nopl (%rax,%rax)
// File: errantlinguist[P]Forecast/include/forecast_io/parsers/../../json/AbstractJsonStateMapParser.hpp
// Function: json::AbstractJsonStateMapParser<forecast_io::parsers::FlagsAttribute>::parseAttribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, json_object* const&)
void parseAttribute(const std::string& key, json_object* const & pValue)
	{
		auto iter = attributeNames.find(key);
		if (iter == attributeNames.end())
		{
			handleUnmappedAttribute(key, pValue);
		}
		else
		{
			const A& attribute = iter->second;
			parseAttribute(attribute, pValue);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x53bb0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0x53c10
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x53be0
testb $0x1, %al
jne 0x53b64
jmp 0x53b78
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x53b9b
leaq -0x20(%rbp), %rdi
callq 0x53c40
movq -0x38(%rbp), %rdi
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: errantlinguist[P]Forecast/include/forecast_io/parsers/../../json/AbstractJsonStateMapParser.hpp
// Function: json::AbstractJsonStateMapParser<forecast_io::parsers::AlertAttribute>::createUndefinedAttributeErrorMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, forecast_io::parsers::AlertAttribute const&)
static std::string createUndefinedAttributeErrorMessage(
			const std::string& attributeType, const A& attribute)
	{
		std::stringstream errorMessage(std::stringstream::out);
		errorMessage << "No parsing logic for " << attributeType << " value "
				<< common::to_quoted_string(attribute) << " is defined.";
		return errorMessage.str();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
movl $0x10, %esi
callq 0xa360
leaq -0x190(%rbp), %rdi
leaq 0x138c9(%rip), %rsi     # 0x681f0
callq 0xa4a0
movq %rax, -0x1d8(%rbp)
jmp 0x54935
movq -0x1d8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa240
movq %rax, -0x1f0(%rbp)
jmp 0x5494e
movq -0x1f0(%rbp), %rdi
leaq 0x13a9d(%rip), %rsi     # 0x683f9
callq 0xa4a0
movq %rax, -0x1f8(%rbp)
jmp 0x5496a
movq -0x18(%rbp), %rsi
leaq -0x1d0(%rbp), %rdi
callq 0x57340
jmp 0x5497c
movq -0x1f8(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xa240
movq %rax, -0x200(%rbp)
jmp 0x54998
movq -0x200(%rbp), %rdi
leaq 0x13860(%rip), %rsi     # 0x68206
callq 0xa4a0
jmp 0x549ad
leaq -0x1d0(%rbp), %rdi
callq 0xa978
movq -0x1e8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xa590
jmp 0x549ce
leaq -0x1a0(%rbp), %rdi
callq 0xa2c0
movq -0x1e0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x54a1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0xa978
leaq -0x1a0(%rbp), %rdi
callq 0xa2c0
movq -0x1a8(%rbp), %rdi
callq 0xa520
nopw %cs:(%rax,%rax)
nop
// File: errantlinguist[P]Forecast/src/forecast_io/parsers/NotifyingFlagParser.cpp
// Function: forecast_io::parsers::NotifyingFlagParser::finishParse()
void NotifyingFlagParser::finishParse()
{
	// If there are no sources to notify about,
	if (sources.empty())
	{
		// If there are stations to notify about,
		if (!stations.empty())
		{
			for (listeners::FlagListener* const & pListener : getListeners())
			{
				pListener->notifyStations(stations);
			}
		}
	} else if (stations.empty())
	{
		// There are sources but no stations to notify about
		for (listeners::FlagListener* const & pListener : getListeners())
		{
			pListener->notifySources(sources);
		}
	} else
	{
		// There are both sources and stations to notify about
		for (listeners::FlagListener* const & pListener : getListeners())
		{
			pListener->notifySources(sources);
			pListener->notifyStations(stations);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x78, %rdi
callq 0x58430
testb $0x1, %al
jne 0x57a46
jmp 0x57acf
movq -0x70(%rbp), %rdi
addq $0xb0, %rdi
callq 0x58450
testb $0x1, %al
jne 0x57aca
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
callq 0x58470
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x58490
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x584c0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x584f0
testb $0x1, %al
jne 0x57a98
jmp 0x57ac8
leaq -0x18(%rbp), %rdi
callq 0x58520
movq -0x70(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
addq $0xb0, %rsi
movq (%rdi), %rax
callq *0x20(%rax)
leaq -0x18(%rbp), %rdi
callq 0x58550
jmp 0x57a85
jmp 0x57aca
jmp 0x57bdc
movq -0x70(%rbp), %rdi
addq $0xb0, %rdi
callq 0x58450
testb $0x1, %al
jne 0x57ae5
jmp 0x57b55
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
callq 0x58470
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x58490
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x584c0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x584f0
testb $0x1, %al
jne 0x57b23
jmp 0x57b50
leaq -0x38(%rbp), %rdi
callq 0x58520
movq -0x70(%rbp), %rsi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rdi
addq $0x78, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
leaq -0x38(%rbp), %rdi
callq 0x58550
jmp 0x57b10
jmp 0x57bda
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
callq 0x58470
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x58490
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x584c0
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x584f0
testb $0x1, %al
jne 0x57b93
jmp 0x57bd8
leaq -0x58(%rbp), %rdi
callq 0x58520
movq -0x70(%rbp), %rsi
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq (%rax), %rdi
addq $0x78, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rax
movq (%rax), %rdi
addq $0xb0, %rsi
movq (%rdi), %rax
callq *0x20(%rax)
leaq -0x58(%rbp), %rdi
callq 0x58550
jmp 0x57b80
jmp 0x57bda
jmp 0x57bdc
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: errantlinguist[P]Forecast/src/forecast_io/parsers/NotifyingFlagParser.cpp
// Function: forecast_io::parsers::NotifyingFlagParser::handleUnmappedAttribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, json_object* const&)
void NotifyingFlagParser::handleUnmappedAttribute(const std::string& key, json_object* const & pValue)
{
	const size_t foundIdx = key.find_last_of(sourceStationAttributeSuffix);
	if (foundIdx == std::string::npos)
	{
		json::AbstractJsonStateMapParser<FlagsAttribute>::handleUnmappedAttribute(key, pValue);
	}
	else
	{
		const std::string sourceName = key.substr(0, foundIdx);
		// Parse all values in the JSON array and add them to the set of station IDs for the given source
		json::insertJsonStringArrayValues(stations, sourceName, pValue);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
movq -0x10(%rbp), %rdi
addq $0x58, %rsi
movq $-0x1, %rdx
callq 0xa870
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x57c3e
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x58580
jmp 0x57c93
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xa7d0
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
addq $0xb0, %rdi
movq -0x18(%rbp), %rdx
callq 0x58620
jmp 0x57c71
leaq -0x40(%rbp), %rdi
callq 0xa978
jmp 0x57c93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa978
jmp 0x57c99
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xa520
nopw %cs:(%rax,%rax)
// File: errantlinguist[P]Forecast/src/forecast_io/parsers/NotifyingFlagParser.cpp
// Function: forecast_io::parsers::NotifyingFlagParser::parseMeasurementSystem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const math::MeasurementSystem& NotifyingFlagParser::parseMeasurementSystem(const MeasurementSystemAttributeValueMap::key_type& attributeValue) const
{
	auto iter = measurementSystemAttributeValues.find(attributeValue);
	if (iter == measurementSystemAttributeValues.end())
	{
		const json::ParseError error = createUnknownMeasurementSystemAttributeValueError(attributeValue);
		throw error;
	}
	else
	{
		const math::MeasurementSystem& measurementSystem = iter->second;
		return measurementSystem;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x50(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x41e30
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x50(%rax), %rdi
callq 0x41e90
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x58a00
testb $0x1, %al
jne 0x580d0
jmp 0x5812b
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x58150
movl $0x10, %edi
callq 0xa2d0
movq -0x60(%rbp), %rsi
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
callq 0x58a30
movq -0x58(%rbp), %rdi
leaq 0x42e8a(%rip), %rsi     # 0x9af90
leaq -0x7bd(%rip), %rdx      # 0x57950
callq 0xa500
jmp 0x5814f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x57950
jmp 0x58146
leaq -0x18(%rbp), %rdi
callq 0x41ec0
addq $0x20, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xa520
nop
// File: errantlinguist[P]Forecast/src/forecast_io/parsers/NotifyingFlagParser.cpp
// Function: forecast_io::parsers::createUnknownMeasurementSystemAttributeValueErrorMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string createUnknownMeasurementSystemAttributeValueErrorMessage(const std::string& attributeValue)
{
	std::stringstream ss(std::stringstream::out);
	ss << "Unknown " << math::MeasurementSystem_NAME << " for attribute value "
			<< common::to_quoted_string(attributeValue) << ".";
	return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
movl $0x10, %esi
callq 0xa360
leaq -0x188(%rbp), %rdi
leaq 0x101df(%rip), %rsi     # 0x683e2
callq 0xa4a0
movq %rax, -0x1d0(%rbp)
jmp 0x58211
movq -0x1d0(%rbp), %rdi
leaq 0x45d91(%rip), %rsi     # 0x9dfb0
callq 0xa240
movq %rax, -0x1e8(%rbp)
jmp 0x5822d
movq -0x1e8(%rbp), %rdi
leaq 0x101b0(%rip), %rsi     # 0x683eb
callq 0xa4a0
movq %rax, -0x1f0(%rbp)
jmp 0x58249
movq -0x10(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x38080
jmp 0x5825b
movq -0x1f0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0xa240
movq %rax, -0x1f8(%rbp)
jmp 0x58277
movq -0x1f8(%rbp), %rdi
leaq 0xdf6f(%rip), %rsi      # 0x661f4
callq 0xa4a0
jmp 0x5828c
leaq -0x1c8(%rbp), %rdi
callq 0xa978
movq -0x1e0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xa590
jmp 0x582ad
leaq -0x198(%rbp), %rdi
callq 0xa2c0
movq -0x1d8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x582fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xa978
leaq -0x198(%rbp), %rdi
callq 0xa2c0
movq -0x1a0(%rbp), %rdi
callq 0xa520
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: errantlinguist[P]Forecast/include/json/json_maps.hpp
// Function: void json::insertJsonStringArrayValues<std::unordered_set<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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::unordered_set<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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, json_object* const&)
void insertJsonStringArrayValues(C& collection, json_object* const & pArray)
{
	const int arrayLength = json_object_array_length(pArray);
	for (int i = 0; i < arrayLength; ++i)
	{
		json_object* const & arrayElement = json_object_array_get_idx(pArray,
				i);
		const std::string& element = json_object_get_string(arrayElement);
		collection.insert(element);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xa380
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5888d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x18(%rbp), %rsi
callq 0xa700
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xa8e0
movq %rax, -0x88(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xa770
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0xdcb0
jmp 0x58807
leaq -0x51(%rbp), %rdi
callq 0xa960
leaq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5b140
movb %dl, -0x91(%rbp)
movq %rax, -0x90(%rbp)
jmp 0x58834
movb -0x91(%rbp), %al
movq -0x90(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movb %al, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa978
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x587a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0xa960
jmp 0x58896
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa978
jmp 0x58896
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xa520
nop
// File: errantlinguist[P]Forecast/src/json/TokenerParser.cpp
// Function: json::TokenerParser::parse(char const* const&, int)
void TokenerParser::parse(const char* const & input, int inputLength)
{
	json_object* const pJsonObj = json_tokener_parse_ex(pTokener, input, inputLength);
	const json_tokener_error parseErrorCode = json_tokener_get_error(pTokener);
	if (json_tokener_continue != parseErrorCode)
	{
		if (json_tokener_success == parseErrorCode)
		{
			parser.parse(pJsonObj);
		}
		else
		{
			const char * jsonErrorDesc = json_tokener_error_desc(parseErrorCode);
			throw json::ParseError(jsonErrorDesc);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %edx
callq 0xa8a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0xa580
movl %eax, -0x24(%rbp)
movl $0x1, %eax
cmpl -0x24(%rbp), %eax
je 0x64845
xorl %eax, %eax
cmpl -0x24(%rbp), %eax
jne 0x647ea
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
leaq -0x20(%rbp), %rsi
callq *0x18(%rax)
jmp 0x64843
movl -0x24(%rbp), %edi
callq 0xa7f0
movq %rax, -0x30(%rbp)
movl $0x10, %edi
callq 0xa2d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rsi
callq 0x64680
jmp 0x64815
movq -0x50(%rbp), %rdi
leaq 0x36770(%rip), %rsi     # 0x9af90
leaq -0xced7(%rip), %rdx     # 0x57950
callq 0xa500
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xa6c0
jmp 0x6484b
jmp 0x64845
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xa520
nopw %cs:(%rax,%rax)
// File: errantlinguist[P]Forecast/src/json/TokenerParser.cpp
// Function: json::TokenerParser::parse(std::istream&, char*, int)
std::streamsize TokenerParser::parse(std::istream& input, char* pBuffer,
		int bufferSize)
{
	std::streamsize result(0);

	while (input.read(pBuffer, bufferSize))
	{
		result += input.gcount();
		parse(pBuffer, bufferSize);
	}
	// Add the number of bytes read for the final read attempt
	result += input.gcount();
	// Parse any remaining tokens
	parse(pBuffer, bufferSize);

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0xa3e0
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0xa2a0
testb $0x1, %al
jne 0x648ad
jmp 0x648d0
movq -0x10(%rbp), %rdi
callq 0xa1c0
movq -0x30(%rbp), %rdi
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edx
leaq -0x18(%rbp), %rsi
callq 0x64780
jmp 0x64887
movq -0x10(%rbp), %rdi
callq 0xa1c0
movq -0x30(%rbp), %rdi
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edx
leaq -0x18(%rbp), %rsi
callq 0x64780
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: errantlinguist[P]Forecast/src/math/Coordinate.cpp
// Function: math::Coordinate::createLatitudeString[abi:cxx11](double)
std::string Coordinate::createLatitudeString(double latitude)
{
	std::stringstream ss(std::stringstream::out);
	ss << std::setprecision(DEFAULT_PRECISION) << std::abs(latitude);
	ss << POLARITY_SEPARATOR;

	if (latitude < 0)
	{
		ss << LATITUDE_NEGATIVE_SYMBOL;

	}
	else
	{
		ss << LATITUDE_POSITIVE_SYMBOL;
	}

	return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
movl $0x10, %esi
callq 0xa360
leaq -0x188(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movl $0x2, %edi
callq 0x64e80
movl %eax, -0x1b0(%rbp)
jmp 0x64956
movq -0x1b8(%rbp), %rdi
movl -0x1b0(%rbp), %eax
movl %eax, -0x19c(%rbp)
movl -0x19c(%rbp), %esi
callq 0xa0c0
movq %rax, -0x1d0(%rbp)
jmp 0x6497d
movsd -0x10(%rbp), %xmm0
callq 0x64ea0
movsd %xmm0, -0x1d8(%rbp)
jmp 0x64991
movsd -0x1d8(%rbp), %xmm0
movq -0x1d0(%rbp), %rdi
callq 0xa680
jmp 0x649a7
leaq -0x188(%rbp), %rdi
leaq 0x3dcb(%rip), %rsi      # 0x68780
callq 0xa4a0
jmp 0x649bc
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x649fb
leaq -0x188(%rbp), %rdi
movl $0x53, %esi
callq 0xa550
jmp 0x649d9
jmp 0x64a10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa2c0
jmp 0x64a41
leaq -0x188(%rbp), %rdi
movl $0x4e, %esi
callq 0xa550
jmp 0x64a0e
jmp 0x64a10
movq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xa590
jmp 0x64a25
leaq -0x198(%rbp), %rdi
callq 0xa2c0
movq -0x1c0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0xa520
nopl (%rax)
// File: errantlinguist[P]Forecast/src/math/Coordinate.cpp
// Function: math::Coordinate::createLongitudeString[abi:cxx11](double)
std::string Coordinate::createLongitudeString(double longitude)
{
	std::stringstream ss(std::stringstream::out);
	ss << std::setprecision(DEFAULT_PRECISION) << std::abs(longitude);
	ss << POLARITY_SEPARATOR;

	if (longitude < 0)
	{
		ss << LONGITUDE_NEGATIVE_SYMBOL;
	}
	else
	{
		ss << LONGITUDE_POSITIVE_SYMBOL;
	}

	return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
movl $0x10, %esi
callq 0xa360
leaq -0x188(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movl $0x2, %edi
callq 0x64e80
movl %eax, -0x1b0(%rbp)
jmp 0x64aa6
movq -0x1b8(%rbp), %rdi
movl -0x1b0(%rbp), %eax
movl %eax, -0x19c(%rbp)
movl -0x19c(%rbp), %esi
callq 0xa0c0
movq %rax, -0x1d0(%rbp)
jmp 0x64acd
movsd -0x10(%rbp), %xmm0
callq 0x64ea0
movsd %xmm0, -0x1d8(%rbp)
jmp 0x64ae1
movsd -0x1d8(%rbp), %xmm0
movq -0x1d0(%rbp), %rdi
callq 0xa680
jmp 0x64af7
leaq -0x188(%rbp), %rdi
leaq 0x3c7b(%rip), %rsi      # 0x68780
callq 0xa4a0
jmp 0x64b0c
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x64b4b
leaq -0x188(%rbp), %rdi
movl $0x57, %esi
callq 0xa550
jmp 0x64b29
jmp 0x64b60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa2c0
jmp 0x64b91
leaq -0x188(%rbp), %rdi
movl $0x45, %esi
callq 0xa550
jmp 0x64b5e
jmp 0x64b60
movq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xa590
jmp 0x64b75
leaq -0x198(%rbp), %rdi
callq 0xa2c0
movq -0x1c0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0xa520
nopl (%rax)
// File: errantlinguist[P]Forecast/src/math/RadialVelocity.cpp
// Function: math::RadialVelocity::dump(std::ostream&) const
std::ostream& RadialVelocity::dump(std::ostream& o) const
{
	o << "RadialVelocity[getMagnitude()=";
	o << common::to_quoted_string(getMagnitude());
	o << ", getDirection()=";
	o << common::to_quoted_string(getDirection());
	o << ']';

	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x378f(%rip), %rsi      # 0x68798
callq 0xa4a0
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x3b8b0
movsd %xmm0, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x651c0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xa240
jmp 0x65047
leaq -0x30(%rbp), %rdi
callq 0xa978
movq -0x10(%rbp), %rdi
leaq 0x375c(%rip), %rsi      # 0x687b7
callq 0xa4a0
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x3b890
movsd %xmm0, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x651c0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0xa240
jmp 0x650a5
leaq -0x68(%rbp), %rdi
callq 0xa978
movq -0x10(%rbp), %rdi
movl $0x5d, %esi
callq 0xa550
movq -0x10(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa978
jmp 0x650f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa978
movq -0x40(%rbp), %rdi
callq 0xa520
nop
// File: hanhwi[P]SimPoint/analysiscode/CmdLineParser.cpp
// Function: CmdLineParser::printExplanationsPretty(std::ostream&) const
void CmdLineParser::printExplanationsPretty(ostream &os) const {
    int prefixWidth = this->calculatePrefixColumnWidth();
    const unsigned int LINE_WIDTH = 80;
    for (unsigned int i = 0; i < allOptions.size(); i++) {
        printExplanationPretty(allOptions[i], prefixWidth, os, LINE_WIDTH);
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x65a0
movl %eax, 0x24(%rsp)
movl $0x50, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x7a10
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x658c
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x7a30
movq (%rax), %rdi
movl 0x24(%rsp), %esi
movq 0x28(%rsp), %rdx
movl $0x50, %ecx
callq 0x6690
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x6531
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/CmdLineParser.cpp
// Function: CmdLineParser::calculatePrefixColumnWidth() const
int CmdLineParser::calculatePrefixColumnWidth() const {
    int prefixWidth = 0;
    for (unsigned int i = 0; i < allOptions.size(); i++) {
        prefixWidth = max(prefixWidth,
                          (int)prettyOptionNameAndArg(allOptions[i]).size());
    }
    return prefixWidth;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x5c(%rsp)
movl $0x0, 0x58(%rsp)
movq 0x18(%rsp), %rdi
movl 0x58(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0x7a10
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x6672
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movl 0x58(%rsp), %eax
movl %eax, %esi
callq 0x7a30
movq (%rax), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x6db0
movq (%rsp), %rdi
callq 0x5270
movl %eax, 0x54(%rsp)
leaq 0x5c(%rsp), %rdi
leaq 0x54(%rsp), %rsi
callq 0x7aa0
movq %rax, 0x8(%rsp)
jmp 0x6633
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x5c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5788
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x65c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5788
jmp 0x667b
movl 0x5c(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/CmdLineParser.cpp
// Function: CmdLineParser::prettyOptionNameAndArg[abi:cxx11](CmdLineOption const*)
string CmdLineParser::prettyOptionNameAndArg(const CmdLineOption *option) {
    string nameAndArg = string("  -") + option->getName();
    if (option->requiresArgument()) {
        nameAndArg = nameAndArg + string(" ") + option->getArgumentName();
    }

    return nameAndArg;
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movb $0x0, 0xe7(%rsp)
leaq 0xbf(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x56a0
movq 0x38(%rsp), %rdx
leaq 0x2c2b1(%rip), %rsi     # 0x330ab
leaq 0xc0(%rsp), %rdi
callq 0x74e0
jmp 0x6e09
movq 0xe8(%rsp), %rdi
callq 0x76e0
movq %rax, 0x20(%rsp)
jmp 0x6e1d
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x7670
jmp 0x6e36
leaq 0xc0(%rsp), %rdi
callq 0x5788
leaq 0xbf(%rsp), %rdi
callq 0x53e0
movq 0xe8(%rsp), %rdi
callq 0x76c0
movb %al, 0x1f(%rsp)
jmp 0x6e63
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x6e70
jmp 0x6fde
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x56a0
movq 0x10(%rsp), %rdx
leaq 0x2f319(%rip), %rsi     # 0x361a4
leaq 0x48(%rsp), %rdi
callq 0x74e0
jmp 0x6e97
movq 0x28(%rsp), %rsi
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x7ae0
jmp 0x6ead
movq 0xe8(%rsp), %rdi
callq 0x7b30
movq %rax, 0x8(%rsp)
jmp 0x6ec1
movq 0x8(%rsp), %rdx
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x7670
jmp 0x6eda
movq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x5470
leaq 0x88(%rsp), %rdi
callq 0x5788
leaq 0x68(%rsp), %rdi
callq 0x5788
leaq 0x48(%rsp), %rdi
callq 0x5788
leaq 0x47(%rsp), %rdi
callq 0x53e0
jmp 0x6fde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x6f53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x5788
leaq 0xbf(%rsp), %rdi
callq 0x53e0
jmp 0x7011
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x7007
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x6fd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x6fc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x5788
leaq 0x48(%rsp), %rdi
callq 0x5788
leaq 0x47(%rsp), %rdi
callq 0x53e0
jmp 0x7007
movb $0x1, 0xe7(%rsp)
testb $0x1, 0xe7(%rsp)
jne 0x6ffa
movq 0x28(%rsp), %rdi
callq 0x5788
movq 0x30(%rsp), %rax
addq $0xf8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x5788
movq 0xb0(%rsp), %rdi
callq 0x5690
nop
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::distSquared(Datapoint const&) const
double Datapoint::distSquared(const Datapoint &dp) const {
    double dist = 0.0;
    unsigned int s = size();
    for (unsigned int i = 0; i < s; i++) {
        dist += ((*this)[i] - dp[i]) * ((*this)[i] - dp[i]);
    }

    return dist;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
callq 0x9b60
movl %eax, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jae 0x8f08
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rdi
subsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movsd 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm0
subsd (%rax), %xmm2
movsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x8e62
movsd 0x30(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::maxNdx(int, int, double*) const
int Datapoint::maxNdx(int start, int end, double *value) const {
    start = start < 0 ? 0 : start;
    if (end == -1) { end = size(); }
    else { end = (end >= (int)size()) ? size() : end; }

    if (size() <= 0 || start >= end || start >= (int)size()) {
        return -1;
    }

    int ndx = start;
    double max = (*this)[start];

    for (unsigned int i = start + 1; i < (unsigned int)end; i++) {
        if ((*this)[i] > max) {
            max = (*this)[i];
            ndx = i;
        }
    }

    if (value) { *value = max; }

    return ndx;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movl %edx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x44(%rsp)
jge 0x8f4f
xorl %eax, %eax
movl %eax, 0x14(%rsp)
jmp 0x8f57
movl 0x44(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x44(%rsp)
cmpl $-0x1, 0x40(%rsp)
jne 0x8f76
movq 0x18(%rsp), %rdi
callq 0x9b60
movl %eax, 0x40(%rsp)
jmp 0x8fb7
movq 0x18(%rsp), %rdi
movl 0x40(%rsp), %eax
movl %eax, 0x10(%rsp)
callq 0x9b60
movq %rax, %rcx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jl 0x8fa4
movq 0x18(%rsp), %rdi
callq 0x9b60
movq %rax, 0x8(%rsp)
jmp 0x8fae
movslq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl %eax, 0x40(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9b60
cmpq $0x0, %rax
jbe 0x8fee
movl 0x44(%rsp), %eax
cmpl 0x40(%rsp), %eax
jge 0x8fee
movq 0x18(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x9b60
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jl 0x8ffb
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x909d
movq 0x18(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, 0x34(%rsp)
movslq 0x44(%rsp), %rsi
callq 0x9b80
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x40(%rsp), %eax
jae 0x907e
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movsd (%rax), %xmm0
ucomisd 0x28(%rsp), %xmm0
jbe 0x906f
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x9071
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x9027
cmpq $0x0, 0x38(%rsp)
je 0x9095
movsd 0x28(%rsp), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movl 0x34(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::operator+=(Datapoint const&)
Datapoint &Datapoint::operator+=(const Datapoint &dp) {
    unsigned int s = size();
    for (unsigned int i = 0; i < s; i++) {
        (*this)[i] += dp[i];
    }

    return *this;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x9b60
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x9126
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movq 0x8(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x9ba0
movsd (%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x90d9
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::operator/=(double)
Datapoint &Datapoint::operator/=(double d) {
    unsigned int s = size();
    for (unsigned int i = 0; i < s; i++) {
        (*this)[i] /= d;
    }

    return *this;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x9b60
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x919d
movq 0x8(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x9ba0
movsd (%rsp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x915a
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::operator-(Datapoint const&) const
Datapoint Datapoint::operator-(const Datapoint &dp) const {
    Datapoint toReturn(*this);
    unsigned int s = size();

    for (unsigned int i = 0; i < s; i++) {
        toReturn[i] -= dp[i];
    }

    return toReturn;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movb $0x0, 0x2f(%rsp)
callq 0x8e00
movq 0x18(%rsp), %rdi
callq 0x9b60
movl %eax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x28(%rsp), %eax
jae 0x92eb
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movq 0x8(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x9ba0
movsd (%rsp), %xmm1
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x929a
movb $0x1, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x9301
movq 0x8(%rsp), %rdi
callq 0x9bc0
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::write(std::ostream&) const
void Datapoint::write(ostream &os) const {
    unsigned int s = size();
    os << s << ": ";

    for (unsigned int i = 0; i < s; i++) {
        os << (*this)[i] << " ";
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x9b60
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x5520
movq %rax, %rdi
leaq 0x29d5f(%rip), %rsi     # 0x330a8
callq 0x5360
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x93a2
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movq (%rsp), %rdi
movsd (%rax), %xmm0
callq 0x5700
movq %rax, %rdi
leaq 0x2ce14(%rip), %rsi     # 0x361a4
callq 0x5360
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x9356
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::write(_IO_FILE*) const
void Datapoint::write(FILE *out) const {
    unsigned int s = size();
    fprintf(out, "%u: ", s);

    for (unsigned int i = 0; i < s; i++) {
        fprintf(out, "%.20f ", (*this)[i]);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x9b60
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x29de4(%rip), %rsi     # 0x331c5
movb $0x0, %al
callq 0x5570
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x9436
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movq (%rsp), %rdi
movsd (%rax), %xmm0
leaq 0x29da8(%rip), %rsi     # 0x331ca
movb $0x1, %al
callq 0x5570
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x93f0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::read(std::istream&)
void Datapoint::read(istream &is) {
    unsigned int length;
    is >> length;

    char c = is.get();
    Utilities::check(':' == c, "Datapoint::read() missing : separator");

    resize(length);

    for (unsigned int i = 0; i < length; i++) {
        is >> (*this)[i];
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x64(%rsp), %rsi
callq 0x5070
movq 0x68(%rsp), %rdi
callq 0x5450
movb %al, 0x63(%rsp)
movb 0x63(%rsp), %al
subb $0x3a, %al
sete %al
movb %al, 0x1f(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x56a0
movq 0x20(%rsp), %rdx
leaq 0x29d34(%rip), %rsi     # 0x331d1
leaq 0x40(%rsp), %rdi
callq 0x74e0
jmp 0x94a9
movb 0x1f(%rsp), %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0x40(%rsp), %rsi
callq 0x7480
jmp 0x94bf
leaq 0x40(%rsp), %rdi
callq 0x5788
leaq 0x3f(%rsp), %rdi
callq 0x53e0
movq 0x10(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, %esi
callq 0x9bd0
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x64(%rsp), %eax
jae 0x955d
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x9ba0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x52e0
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x94eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x9551
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5788
leaq 0x3f(%rsp), %rdi
callq 0x53e0
jmp 0x9562
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5690
nopl (%rax)
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::read(_IO_FILE*)
void Datapoint::read(FILE *in) {
    unsigned int length;
    fscanf(in, "%u", &length);

    char c = fgetc(in);
    Utilities::check(':' == c, "Datapoint::read() missing : separator");

    resize(length);

    for (unsigned int i = 0; i < length; i++) {
        fscanf(in, "%lf", &(*this)[i]);
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x29c63(%rip), %rsi     # 0x331f7
xorl %eax, %eax
leaq 0x64(%rsp), %rdx
callq 0x56e0
movq 0x68(%rsp), %rdi
callq 0x55f0
movb %al, 0x63(%rsp)
movb 0x63(%rsp), %al
subb $0x3a, %al
sete %al
movb %al, 0x1f(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x56a0
movq 0x20(%rsp), %rdx
leaq 0x29bfb(%rip), %rsi     # 0x331d1
leaq 0x40(%rsp), %rdi
callq 0x74e0
jmp 0x95e2
movb 0x1f(%rsp), %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0x40(%rsp), %rsi
callq 0x7480
jmp 0x95f8
leaq 0x40(%rsp), %rdi
callq 0x5788
leaq 0x3f(%rsp), %rdi
callq 0x53e0
movq 0x10(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, %esi
callq 0x9bd0
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x64(%rsp), %eax
jae 0x969f
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x9ba0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x29ba3(%rip), %rsi     # 0x331fa
movb $0x0, %al
callq 0x56e0
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x9624
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x9693
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5788
leaq 0x3f(%rsp), %rdi
callq 0x53e0
jmp 0x96a4
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5690
nop