LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/console_weather/ForecastStreamReader.cpp
// Function: console_weather::ForecastStreamReader::read(std::istream&)
std::unique_ptr<forecast_io::Forecast> ForecastStreamReader::read(std::istream& input)
{
    // Create parsers
    std::unique_ptr<forecast_io::factories::ForecastFactory> pForecastFactory(
        new forecast_io::factories::ForecastFactory(measurementUnits));
    std::unique_ptr<forecast_io::factories::FlagsFactory> pFlagsFactory(
        new forecast_io::factories::FlagsFactory(measurementUnits));
    std::unique_ptr<forecast_io::parsers::ParserManager> pParserManager(
        new forecast_io::parsers::ParserManager(pForecastFactory.get(), pFlagsFactory.get()));

    forecast_io::parsers::NotifyingForecastParser& forecastParser =
        pParserManager->getForecastParser();
    json::TokenerParser tokenerParser(forecastParser);
    const std::streamsize bytesRead = tokenerParser.parse(input, pBuffer.get(),
                                      readBufferSize);
	std::unique_ptr<forecast_io::Forecast> result = nullptr;
	if (input.eof() && bytesRead > 0)
	{
		result = pForecastFactory->create();
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
movl $0x78, %edi
callq 0x90e0
movq %rax, %rbx
movq (%rbp), %rsi
movq %rax, %rdi
callq 0x1fb70
movl $0xa0, %edi
callq 0x90e0
movq %rax, %r14
movq (%rbp), %rsi
movq %rax, %rdi
callq 0x1f8dc
movl $0x348, %edi            # imm = 0x348
callq 0x90e0
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x28df0
movq (%r12), %rax
movq %r12, %rdi
callq *0x48(%rax)
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x2929c
movq 0x8(%rbp), %rdx
movl 0x10(%rbp), %ecx
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x29386
movq $0x0, (%r15)
testq %rax, %rax
jle 0x1a2d8
movq (%r13), %rax
movq -0x18(%rax), %rax
movl 0x20(%r13,%rax), %eax
andl $0x2, %eax
je 0x1a2d8
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x10(%rax)
leaq 0x8(%rsp), %r13
movq (%r13), %rsi
movq $0x0, (%r13)
movq %r15, %rdi
callq 0x1a186
movq %r13, %rdi
callq 0xc4f0
leaq 0x10(%rsp), %rdi
callq 0x292c6
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq %r15, %rdi
callq 0xc4f0
jmp 0x1a320
movq %rax, %r13
leaq 0x10(%rsp), %rdi
callq 0x292c6
jmp 0x1a331
jmp 0x1a32e
movq %rax, %r13
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
jmp 0x1a340
movq %rax, %r13
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r13, %rdi
callq 0x9390
movq %rax, %r13
jmp 0x1a349
nop
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/console_weather/writers/AlertConsoleWriter.cpp
// Function: console_weather::writers::AlertConsoleWriter::write(forecast_io::Alert const&, std::ostream&)
void AlertConsoleWriter::write(const forecast_io::Alert& value, std::ostream& output)
{
	output << value.getTitle() << '\n';
	output << headerSeparator << '\n';
	output << value.getDescription();
	output << "\nFor more information see " << value.getUri() << '\n';
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x14268
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x95c0
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x95c0
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a3f2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x95c0
leaq 0x10(%rsp), %r15
movb $0xa, (%r15)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x95c0
movq %r13, (%r15)
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x14268
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x95c0
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a45b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x10ddd(%rip), %rsi     # 0x2b23f
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x95c0
leaq 0x10(%rsp), %r15
movq %r13, (%r15)
movq 0x50(%r14), %rsi
movq 0x58(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x14268
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x95c0
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x95c0
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a4c5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1a4d7
jmp 0x1a4d7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a4f1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rdi
callq 0x9390
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/console_weather/writers/SynchronicDataPointConsoleWriter.cpp
// Function: console_weather::writers::SynchronicDataPointConsoleWriter::write(forecast_io::SynchronicDataPoint const&, std::ostream&)
void SynchronicDataPointConsoleWriter::write(const forecast_io::SynchronicDataPoint& value, std::ostream& output)
{
	const forecast_io::SingleDataPoint& baseDataPoint = value.getBaseDataPoint();
	write(baseDataPoint, output);
	const math::RelativePosition<double, double>& nearestStorm = value.getNearestStorm();
	output << nearestStormSectionHeader << '\n';
	writers::write(nearestStorm, output);
	output << headerRowSeparator << '\n';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1ae8e
movsd 0xd8(%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xe0(%r15), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x95c0
movb $0xa, %bpl
leaq 0x3(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x95c0
leaq 0x10680(%rip), %rsi     # 0x2b433
movl $0x9, %edx
movq %rbx, %rdi
callq 0x95c0
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x9490
movq %rax, %r15
leaq 0x105d7(%rip), %rsi     # 0x2b3af
movl $0x2, %edx
movq %rax, %rdi
callq 0x95c0
leaq 0x4(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x95c0
leaq 0x10648(%rip), %rsi     # 0x2b449
movl $0xa, %edx
movq %rbx, %rdi
callq 0x95c0
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x9490
leaq 0x5(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x95c0
movq %rax, %r15
leaq 0x105a8(%rip), %rsi     # 0x2b3e3
movl $0x2, %edx
movq %rax, %rdi
callq 0x95c0
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x95c0
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
movq %rbx, %rdi
callq 0x95c0
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x95c0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/console_weather/writers/SynchronicDataPointConsoleWriter.cpp
// Function: console_weather::writers::SynchronicDataPointConsoleWriter::write(forecast_io::SingleDataPoint const&, std::ostream&)
void SynchronicDataPointConsoleWriter::write(const forecast_io::SingleDataPoint& value, std::ostream& output)
{
	const forecast_io::DataPoint& baseDataPoint = value.getBaseDataPoint();
	write(baseDataPoint, output);
	output << "Temperature: " << value.getTemperature() << DEGREE_SYMBOL << ' ' << TEMPERATURE_UNITS << '\n';
	output << "Apparent temperature: " << value.getApparentTemperature() << DEGREE_SYMBOL << ' ' << TEMPERATURE_UNITS << '\n';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
callq 0x1afb2
leaq 0x1053b(%rip), %rsi     # 0x2b3e6
movl $0xd, %edx
movq %rbx, %rdi
callq 0x95c0
movsd 0xc8(%r14), %xmm0
movq %rbx, %rdi
callq 0x9490
movq %rax, %r12
leaq 0x104dc(%rip), %r15     # 0x2b3af
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x95c0
movb $0x20, %bpl
leaq 0x2(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x95c0
movb $0x46, %r12b
leaq 0x3(%rsp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x95c0
movb $0xa, %r13b
leaq 0x4(%rsp), %rsi
movb %r13b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x95c0
leaq 0x104c2(%rip), %rsi     # 0x2b3f4
movl $0x16, %edx
movq %rbx, %rdi
callq 0x95c0
movsd 0xd0(%r14), %xmm0
movq %rbx, %rdi
callq 0x9490
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x95c0
leaq 0x5(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x95c0
leaq 0x6(%rsp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x95c0
leaq 0x7(%rsp), %rsi
movb %r13b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x95c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/curl/CallbackClient.cpp
// Function: curl::CallbackClient::CallbackClient(char* const&)
CallbackClient::CallbackClient(char* const& pErrorBuffer) : pCurlHandle(curl_easy_init()), pErrorBuffer(pErrorBuffer), pHeaders(NULL)
{
	if (pCurlHandle)
	{
		CURLcode setupResult = setupHandle(pCurlHandle);
		if (CURLE_OK != setupResult)
		{
			throw setupResult;
		}
	} else
	{
		throw CURLE_FAILED_INIT;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x21bb7(%rip), %rax     # 0x3d3a0
movq %rax, (%rdi)
callq 0x95d0
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
testq %rax, %rax
je 0x1b81e
leaq 0x8(%rbx), %rsi
movq %rbx, %rdi
callq 0x1b850
testl %eax, %eax
jne 0x1b830
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4, %edi
callq 0x91c0
movl $0x2, (%rax)
jmp 0x1b83e
movl %eax, %ebx
movl $0x4, %edi
callq 0x91c0
movl %ebx, (%rax)
leaq 0x21823(%rip), %rsi     # 0x3d068
movq %rax, %rdi
xorl %edx, %edx
callq 0x9370
nop
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/curl/CallbackClient.cpp
// Function: curl::CallbackClient::setupHandle(void*&)
CURLcode CallbackClient::setupHandle(CURL*& pCurlHandle)
{
	CURLcode result(curl_easy_setopt(pCurlHandle, CURLOPT_ERRORBUFFER, pErrorBuffer));
	if (CURLE_OK == result)
	{
		result = curl_easy_setopt(pCurlHandle, CURLOPT_NOPROGRESS, 1L);
		if (CURLE_OK == result)
		{
			result = curl_easy_setopt(pCurlHandle, CURLOPT_FOLLOWLOCATION, 1L);
		}
	}

	return result;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x10(%rdi), %rcx
movq (%rcx), %rdx
movq %rax, %rdi
movl $0x271a, %esi           # imm = 0x271A
xorl %eax, %eax
callq 0x94f0
testl %eax, %eax
jne 0x1b889
movq (%rbx), %rdi
movl $0x1, %edx
movl $0x2b, %esi
xorl %eax, %eax
callq 0x94f0
testl %eax, %eax
je 0x1b88b
popq %rbx
retq
movq (%rbx), %rdi
movl $0x1, %edx
movl $0x34, %esi
xorl %eax, %eax
popq %rbx
jmp 0x94f0
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/curl/CallbackClient.cpp
// Function: curl::CallbackClient::~CallbackClient()
CallbackClient::~CallbackClient()
{
	// Clean up resources for cURL library
	curl_easy_cleanup(pCurlHandle);
	if (pHeaders != NULL)
	{
		curl_slist_free_all(pHeaders);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x21af5(%rip), %rax     # 0x3d3a0
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
callq 0x90b0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1b8c5
callq 0x9530
popq %rbx
retq
movq %rax, %rdi
callq 0xc4e5
nop
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/curl/CallbackClient.cpp
// Function: curl::CallbackClient::addHeader(char const* const&)
bool CallbackClient::addHeader(const char* const& pHeader)
{
	bool result(false);

	curl_slist* pNewHeaders = curl_slist_append(pHeaders, pHeader);
	if (pNewHeaders != NULL)
	{
		pHeaders = pNewHeaders;
		result = true;
	}

	return result;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rsi), %rsi
callq 0x93a0
testq %rax, %rax
je 0x1b901
movq %rax, 0x18(%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/curl/CallbackClient.cpp
// Function: curl::CallbackClient::read(char const*, unsigned long (*)(char*, unsigned long, unsigned long, void*), void*, long)
CURLcode CallbackClient::read(const char* url, WriteFunction* pCallback, void* pUserData,
		long timeout)
{
	CURLcode result(CURLE_FAILED_INIT);

	if (
			CURLE_OK == (result = curl_easy_setopt(pCurlHandle, CURLOPT_WRITEFUNCTION, pCallback))
			&& CURLE_OK == (result = curl_easy_setopt(pCurlHandle, CURLOPT_WRITEDATA, pUserData))
			&& CURLE_OK == (result = curl_easy_setopt(pCurlHandle, CURLOPT_TIMEOUT, timeout))
			&& CURLE_OK == (result = curl_easy_setopt(pCurlHandle, CURLOPT_URL, url)))
	{
		if (pHeaders != NULL)
		{
			result = curl_easy_setopt(pCurlHandle, CURLOPT_HTTPHEADER, pHeaders);
			if (CURLE_OK == result)
			{
				result = curl_easy_perform(pCurlHandle);
			}
		}
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl $0x4e2b, %esi           # imm = 0x4E2B
xorl %eax, %eax
callq 0x94f0
testl %eax, %eax
jne 0x1b985
movq 0x8(%rbx), %rdi
movl $0x2711, %esi           # imm = 0x2711
movq %r12, %rdx
xorl %eax, %eax
callq 0x94f0
testl %eax, %eax
jne 0x1b985
movq 0x8(%rbx), %rdi
movl $0xd, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x94f0
testl %eax, %eax
jne 0x1b985
movq 0x8(%rbx), %rdi
xorl %ebp, %ebp
movl $0x2712, %esi           # imm = 0x2712
movq %r14, %rdx
xorl %eax, %eax
callq 0x94f0
testl %eax, %eax
je 0x1b992
movl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0x1b987
movq 0x8(%rbx), %rdi
movl $0x2727, %esi           # imm = 0x2727
xorl %eax, %eax
callq 0x94f0
testl %eax, %eax
jne 0x1b985
movq 0x8(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x93c0
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/forecast_io/Alert.cpp
// Function: forecast_io::Alert::hash() const
size_t Alert::hash() const
{
	size_t result(1U);
	static constexpr size_t prime = 31;

	static std::hash<std::string> str_hash;
	result = prime * result + (str_hash(title));
	result = prime * result + (str_hash(description));
	result = prime * result + (str_hash(uri));

	static std::hash<time_t> time_t_hash;
	result = prime * result + (time_t_hash(expiryTime));

	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
leaq 0x23e9f(%rip), %r14     # 0x3fb50
movq %r14, %rdi
callq 0x1c016
movq %rax, %r15
shlq $0x5, %r15
subq %rax, %r15
leaq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x1c016
addq %r15, %rax
movq %rax, %r15
shlq $0x5, %r15
subq %rax, %r15
leaq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x1c016
addq %r15, %rax
movq %rax, %rcx
shlq $0x5, %rcx
subq %rax, %rcx
movq 0x28(%rbx), %rax
addq %rcx, %rax
addq $0xe1781, %rax          # imm = 0xE1781
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/forecast_io/DataOverview.cpp
// Function: forecast_io::DataOverview::dump(std::ostream&) const
std::ostream& DataOverview::dump(std::ostream& o) const
{
	o << "DataOverview[getSummary()=";
	o << common::to_quoted_string(getSummary());
	o << ", getIconName()=";
	o << common::to_quoted_string(getIconName());
	o << ']';

	return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf2c5(%rip), %rsi      # 0x2b659
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x95c0
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x14268
movq %rsp, %rdi
movq %r15, %rsi
callq 0x19e8b
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x95c0
leaq 0x10(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x1c3fa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x90a0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c411
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0xf25c(%rip), %rsi      # 0x2b674
movl $0x10, %edx
movq %rbx, %rdi
callq 0x95c0
leaq 0x20(%rsp), %r15
movq %r12, (%r15)
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x14268
movq %rsp, %rdi
movq %r15, %rsi
callq 0x19e8b
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x95c0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1c472
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x90a0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c489
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rsp, %rsi
movb $0x5d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x95c0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
jne 0x1c4ce
jmp 0x1c4e0
jmp 0x1c4dd
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c4e0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x90a0
jmp 0x1c4e0
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c4f7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rdi
callq 0x9390
nop
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/forecast_io/Flags.cpp
// Function: forecast_io::Flags::dump(std::ostream&) const
std::ostream& Flags::dump(std::ostream& o) const
{
	o << "Flags[hasMetnoLicense()=";
	o << common::to_quoted_string(hasMetnoLicense());
	o << ", isDarkskyUnavailable()=";
	o << common::to_quoted_string(isDarkskyUnavailable());
	o << ", getSources()=";
	o << common::to_collection_string(getSources());
	o << ", getStations()=";
	o << common::to_collection_string(getStations());
	o << ", getUnits()=";
	const math::MeasurementSystem units = getUnits();
	const std::string& defaultUnitsName = MeasurementSystemDefaultNameArrayHolder::getName(units);
	o << defaultUnitsName;
	o << ']';

	return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xee81(%rip), %rsi      # 0x2b6a3
movl $0x18, %edx
movq %rbx, %rdi
callq 0x95c0
movb 0x9(%r14), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x19f4e
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x95c0
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x1c872
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0xee43(%rip), %rsi      # 0x2b6bc
movl $0x19, %edx
movq %rbx, %rdi
callq 0x95c0
movb 0x8(%r14), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x19f4e
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x95c0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c8c4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0xee0b(%rip), %rsi      # 0x2b6d6
movl $0xf, %edx
movq %rbx, %rdi
callq 0x95c0
leaq 0x10(%r14), %rsi
leaq 0xee38(%rip), %rdx      # 0x2b71b
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1d628
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x95c0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c916
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0xedc9(%rip), %rsi      # 0x2b6e6
movl $0x10, %edx
movq %rbx, %rdi
callq 0x95c0
leaq 0x48(%r14), %rsi
leaq 0xede6(%rip), %rdx      # 0x2b71b
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1d7c3
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x95c0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c968
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0xed88(%rip), %rsi      # 0x2b6f7
movl $0xd, %edx
movq %rbx, %rdi
callq 0x95c0
movq 0x80(%r14), %rdi
callq 0x1ebd0
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x95c0
leaq 0x8(%rsp), %rsi
movb $0x5d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x95c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1c9bf
jmp 0x1c9bf
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c9d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rdi
callq 0x9390
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x1c9cc
jmp 0x1c9d9
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/include/common/to_string.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> common::to_string<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>>, char, char>(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, std::pair<char, char> const&)
std::string to_string(const std::pair<L, R>& value,
		const std::pair<LD, RD>& delimiters)
{
	std::stringstream ss(std::stringstream::out);

	ss << delimiters.first << to_quoted_string(value.first)
			<< SEQUENCE_ELEMENT_SEPARATOR << to_quoted_string(value.second)
			<< delimiters.second;

	return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
movl $0x10, %esi
callq 0x9220
leaq 0x60(%rsp), %rdi
movb (%r14), %al
leaq 0x10(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
callq 0x95c0
movq %rax, %r12
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x19e8b
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x95c0
movq 0x221ab(%rip), %rsi     # 0x3fb98
movq 0x221ac(%rip), %rdx     # 0x3fba0
movq %rax, %rdi
callq 0x95c0
movq %rax, %r12
addq $0x20, %r15
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x19e8b
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %r12, %rdi
callq 0x95c0
movb 0x1(%r14), %cl
leaq 0xf(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x95c0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1da55
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1da70
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x91d0
movq 0x2151c(%rip), %rsi     # 0x3efa0
leaq 0x50(%rsp), %rdi
callq 0x9470
leaq 0xd0(%rsp), %rdi
callq 0x9420
movq %rbx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1dad6
jmp 0x1dad1
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dad9
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x90a0
jmp 0x1dad9
movq %rax, %rbx
jmp 0x1daf4
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1daf4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
movq 0x214a5(%rip), %rsi     # 0x3efa0
leaq 0x50(%rsp), %rdi
callq 0x9470
leaq 0xd0(%rsp), %rdi
callq 0x9420
movq %rbx, %rdi
callq 0x9390
nop
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/forecast_io/MeasurementSystemDefaultAttributeValueMapHolder.cpp
// Function: forecast_io::MeasurementSystemDefaultAttributeValueMapHolder::findMeasurementSystem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
const math::MeasurementSystem* MeasurementSystemDefaultAttributeValueMapHolder::findMeasurementSystem(MeasurementSystemAttributeValueMap::key_type attributeValue)
{
	const math::MeasurementSystem* result(nullptr);

	const MeasurementSystemAttributeValueMap& measurementSystemAttributeValues = *getInstance();
	auto iter = measurementSystemAttributeValues.find(attributeValue);
	if (iter != measurementSystemAttributeValues.end())
	{
		const math::MeasurementSystem& measurementSystem = iter->second;
		result = &measurementSystem;
	}
	return result;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1e618
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x1eb00
leaq 0x28(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/forecast_io/MeasurementSystemDefaultAttributeValueMapHolder.cpp
// Function: forecast_io::MeasurementSystemDefaultAttributeValueMapHolder::createInstance[abi:cxx11]()
std::unique_ptr<MeasurementSystemAttributeValueMap> MeasurementSystemDefaultAttributeValueMapHolder::createInstance()
{
	std::unique_ptr<MeasurementSystemAttributeValueMap> result(
			new MeasurementSystemAttributeValueMap(
					math::MeasurementSystem_COUNT));
	insertDefaultMeasurementSystems(*result);
	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x38, %edi
callq 0x90e0
movq %rax, %r14
leaq 0x8(%rsp), %rdx
leaq 0x7(%rsp), %rcx
leaq 0x6(%rsp), %r8
movl $0x4, %esi
movq %rax, %rdi
callq 0x1eb3a
movq %r14, (%rbx)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movw $0x6163, (%r12)         # imm = 0x6163
movq $0x2, -0x8(%r12)
movb $0x0, 0x2(%r12)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1e722
movq $0x0, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1e4d3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movw $0x6973, 0x10(%rsi)     # imm = 0x6973
movq $0x2, 0x8(%rsi)
movb $0x0, 0x12(%rsi)
movq %r14, %rdi
callq 0x1e722
movq $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1e513
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movw $0x6b75, 0x10(%rsi)     # imm = 0x6B75
movq $0x2, 0x8(%rsi)
movb $0x0, 0x12(%rsi)
movq %r14, %rdi
callq 0x1e722
movq $0x2, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1e553
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movw $0x7375, 0x10(%rsi)     # imm = 0x7375
movq $0x2, 0x8(%rsi)
movb $0x0, 0x12(%rsi)
movq %r14, %rdi
callq 0x1e722
movq $0x3, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1e593
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1e5a8
jmp 0x1e5a8
jmp 0x1e5a8
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1e5c2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rdi
callq 0x1e5e4
jmp 0x1e5dc
movq %rax, %r15
movl $0x38, %esi
movq %r14, %rdi
callq 0x90a0
movq %r15, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/forecast_io/MeasurementSystemDefaultNameArrayHolder.cpp
// Function: forecast_io::MeasurementSystemDefaultNameArrayHolder::createInstance[abi:cxx11]()
std::unique_ptr<MeasurementSystemNameArray> MeasurementSystemDefaultNameArrayHolder::createInstance()
{
	std::unique_ptr<MeasurementSystemNameArray> result(
			new MeasurementSystemNameArray());
	insertDefaultMeasurementSystemNames(*result);
	return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x80, %edi
callq 0x90e0
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x70(%rax)
movl $0x10, %eax
leaq (%r14,%rax), %rcx
movq %rcx, -0x10(%r14,%rax)
movq $0x0, -0x8(%r14,%rax)
movb $0x0, (%r14,%rax)
addq $0x20, %rax
cmpq $0x90, %rax
jne 0x1ec21
movq %r14, (%rbx)
movq 0x8(%r14), %rdx
leaq 0xcacd(%rip), %rcx      # 0x2b71f
movl $0x11, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x92c0
leaq 0x20(%r14), %rdi
movq 0x28(%r14), %rdx
leaq 0xbc1b(%rip), %rcx      # 0x2a88c
movl $0x2, %r8d
xorl %esi, %esi
callq 0x92c0
leaq 0x40(%r14), %rdi
movq 0x48(%r14), %rdx
leaq 0xcaa4(%rip), %rcx      # 0x2b731
movl $0xb, %r8d
xorl %esi, %esi
callq 0x92c0
movq %r14, %rdi
addq $0x60, %rdi
movq 0x68(%r14), %rdx
leaq 0xca91(%rip), %rcx      # 0x2b73d
movl $0xb, %r8d
xorl %esi, %esi
callq 0x92c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x1ecd7
movq %rbx, %rdi
callq 0x1a7fa
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O1/errantlinguist[P]Forecast/src/forecast_io/parsers/AlertsFactoryParser.cpp
// Function: forecast_io::parsers::AlertsFactoryParser::handleArrayElement(json_object* const&)
void AlertsFactoryParser::handleArrayElement(json_object* const & arrayElement)
{
    json::JsonArrayParser<NotifyingAlertParser>::handleArrayElement(arrayElement);
    Alert alert = factory.create();
    for (listeners::AlertsListener* const & pListener : getListeners())
    {
        pListener->notifyAlert(alert);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x50(%rbx), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x10(%rax)
addq $0x28, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2122b
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
jmp 0x21214
leaq 0x8(%rsp), %rdi
callq 0x1c032
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1c032
movq %rbx, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x9240
movq %rax, %r15
testl %r15d, %r15d
jle 0x213a0
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
leaq 0x8(%rsp), %r13
movq (%r14), %rdi
movq %r12, %rsi
callq 0x9550
movq %rax, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
callq *0x28(%rax)
incq %r12
cmpq %r12, %r15
jne 0x2137c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0x38, %edi
callq 0x90e0
movq %rax, %r14
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0xf(%rsp), %r8
movl $0x4, %esi
movq %rax, %rdi
callq 0x23450
movq %r14, (%rbx)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x30(%rsp), %rsi
movq $0x13, (%rsi)
leaq 0x10(%rsp), %rdi
xorl %edx, %edx
callq 0x93d0
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsi)
movups 0x91ea(%rip), %xmm0     # 0x2c016
movups %xmm0, (%rax)
movl $0x656c6261, 0xf(%rax)  # imm = 0x656C6261
movq %rcx, 0x8(%rsi)
movq (%rsi), %rax
movb $0x0, (%rax,%rcx)
movq %r14, %rdi
callq 0x22fce
movl $0x0, (%rax)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x22e66
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
movabsq $0x696c2d6f6e74656d, %rax # imm = 0x696C2D6F6E74656D
movq %rax, 0x10(%rsi)
movabsq $0x65736e6563696c2d, %rax # imm = 0x65736E6563696C2D
movq %rax, 0x15(%rsi)
movq $0xd, 0x8(%rsi)
movb $0x0, 0x1d(%rsi)
movq %r14, %rdi
callq 0x22fce
movl $0x1, (%rax)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x22ebb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
movl $0x72756f73, 0x10(%rsi) # imm = 0x72756F73
movl $0x73656372, 0x13(%rsi) # imm = 0x73656372
movq $0x7, 0x8(%rsi)
movb $0x0, 0x17(%rsi)
movq %r14, %rdi
callq 0x22fce
movl $0x2, (%rax)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x22f02
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
movl $0x74696e75, 0x10(%rsi) # imm = 0x74696E75
movw $0x73, 0x14(%rsi)
movq $0x5, 0x8(%rsi)
movq %r14, %rdi
callq 0x22fce
movl $0x3, (%rax)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x22f44
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x22f59
jmp 0x22f59
jmp 0x22f59
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x22f78
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
jmp 0x22f78
movq %rax, %r15
movq %rbx, %rdi
callq 0x22f9a
movq %r15, %rdi
callq 0x9390
movq %rax, %r15
movl $0x38, %esi
movq %r14, %rdi
callq 0x90a0
jmp 0x22f80
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x2367e
movq 0xe8(%rbx), %rsi
movq (%rsi), %rax
movq %rsp, %r14
movq %r14, %rdi
callq *0x10(%rax)
addq $0x100, %rbx            # imm = 0x100
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x23621
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
jmp 0x2360a
leaq 0x19e40(%rip), %rax     # 0x3d468
addq $0x10, %rax
leaq 0x48(%rsp), %rdi
movq %rax, -0x48(%rdi)
callq 0xc7e2
leaq 0x10(%rsp), %rdi
callq 0xc8b6
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x19e0f(%rip), %rax     # 0x3d468
addq $0x10, %rax
leaq 0x48(%rsp), %rdi
movq %rax, -0x48(%rdi)
callq 0xc7e2
leaq 0x10(%rsp), %rdi
callq 0xc8b6
movq %rbx, %rdi
callq 0x9390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq $0x0, (%r14)
movq (%rsi), %rdi
callq 0x9110
movq 0x8(%rax), %rax
xorl %r15d, %r15d
leaq 0x18(%rsp), %r12
leaq 0xf(%rsp), %r13
xorl %ebp, %ebp
testq %rax, %rax
je 0x236cb
movq (%rax), %r15
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rbp
testq %rax, %rax
je 0x2370d
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xc420
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x23ebe
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x23708
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbp, %rax
jmp 0x236b6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x23744
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x23f0c
testq %rax, %rax
je 0x23ef5
addq $0x28, %rax
movq (%r14), %rcx
movq 0x30(%rcx), %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
movq (%r14), %rax
movq 0x28(%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movl $0x10, %esi
callq 0x9220
leaq 0x30(%rsp), %r12
leaq 0x7ec6(%rip), %rsi      # 0x2c10c
movl $0x15, %edx
movq %r12, %rdi
callq 0x95c0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x95c0
movq %rax, %r15
leaq 0x80a4(%rip), %rsi      # 0x2c310
movl $0x7, %edx
movq %rax, %rdi
callq 0x95c0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x24dbc
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x95c0
leaq 0x7e86(%rip), %rsi      # 0x2c122
movl $0xc, %edx
movq %rax, %rdi
callq 0x95c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x242c4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x91d0
movq 0x1acc8(%rip), %rsi     # 0x3efa0
leaq 0x20(%rsp), %rdi
callq 0x9470
leaq 0xa0(%rsp), %rdi
callq 0x9420
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x24323
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24326
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x90a0
jmp 0x24326
movq %rax, %rbx
movq 0x1ac73(%rip), %rsi     # 0x3efa0
leaq 0x20(%rsp), %rdi
callq 0x9470
leaq 0xa0(%rsp), %rdi
callq 0x9420
movq %rbx, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
leaq 0xb0(%rdi), %rbx
cmpq $0x0, 0x90(%rdi)
movq 0x28(%rdi), %r15
movq 0xc8(%rdi), %rax
je 0x25136
movq %rdi, %r14
addq $0x78, %r14
testq %rax, %rax
jne 0x25118
jmp 0x2512f
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r15), %r15
testq %r15, %r15
jne 0x250fb
jmp 0x2515b
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
movq (%r15), %r15
testq %r15, %r15
jne 0x2511f
jmp 0x2515b
testq %r15, %r15
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
jne 0x2515b
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x20(%rax)
movq (%r15), %r15
testq %r15, %r15
jne 0x25146
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x58(%rdi), %rsi
movq 0x60(%rdi), %rcx
movq %r15, %rdi
movq $-0x1, %rdx
callq 0x94d0
cmpq $-0x1, %rax
je 0x251e4
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x9600
addq $0xb0, %r14
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x25714
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x251d8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x25690
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2521b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rdi
callq 0x9390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x50(%rdi), %rdi
callq 0x1eb00
testq %rax, %rax
je 0x25402
addq $0x28, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2545f
movl $0x10, %edi
callq 0x91c0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x9560
leaq 0x19437(%rip), %rax     # 0x3e868
movq %rax, (%rbx)
leaq 0x17c15(%rip), %rsi     # 0x3d050
movq 0x19b16(%rip), %rdx     # 0x3ef58
movq %rbx, %rdi
callq 0x9370
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9708
movq %rbx, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x9240
movq %rax, %r15
testl %r15d, %r15d
jle 0x258cf
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
leaq 0x8(%rsp), %r13
movq %rsp, %rbp
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x9550
movq %rax, %rdi
callq 0x96c0
movq %r13, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0xc420
movq %r14, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x266a8
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x258c7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
incq %r12
cmpq %r12, %r15
jne 0x25878
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x258fd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rdi
callq 0x9390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rsi), %rsi
callq 0x9670
movq %rax, (%rsp)
movq 0x8(%rbx), %rdi
callq 0x93f0
cmpl $0x1, %eax
je 0x29332
testl %eax, %eax
jne 0x2933a
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
callq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0x9630
movq %rax, %r14
movl $0x10, %edi
callq 0x91c0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x29286
leaq 0x13ced(%rip), %rsi     # 0x3d050
movq 0x15bee(%rip), %rdx     # 0x3ef58
movq %rbx, %rdi
callq 0x9370
movq %rax, %r14
movq %rbx, %rdi
callq 0x9510
movq %r14, %rdi
callq 0x9390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movslq %ecx, %rbp
movq %rsi, %rdi
movq %rdx, %rsi
movq %rbp, %rdx
callq 0x9290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x293ca
xorl %r13d, %r13d
jmp 0x293ff
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbx
addq 0x8(%r15), %r13
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x292fc
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x9290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x293d2
addq 0x8(%r15), %r13
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl 0xc(%rsp), %edx
callq 0x292fc
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop