LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/errantlinguist[P]Forecast/src/main.cpp
// Function: isLastResponseContentInvalid(curl::CallbackClient const&, char* const&)
static bool isLastResponseContentInvalid(const curl::CallbackClient& curlClient, char* const& pInfoBuffer)
{
	bool result(false);

	CURLcode infoGetterCode = curlClient.getInfo(CURLINFO_CONTENT_TYPE, pInfoBuffer);
	if (CURLE_OK == infoGetterCode && pInfoBuffer != NULL)
	{
		const std::string infoType(pInfoBuffer);
		std::smatch jsonMatch;
		result = (!std::regex_match(infoType, jsonMatch, VALID_CONTENT_TYPE_REGEX));
	}

	return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq (%rsi), %rdx
movl $0x100012, %esi         # imm = 0x100012
callq 0x1b91a
testl %eax, %eax
setne %al
movq (%rbx), %rsi
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0xc360
xorl %ebx, %ebx
jmp 0xc3d1
leaq 0x28(%rsp), %rbx
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc40a
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
leaq 0x33500(%rip), %rcx     # 0x3f890
movq %rsp, %rdx
xorl %r8d, %r8d
callq 0xc944
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc3b3
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x90a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc3ce
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x90a0
xorb $0x1, %bl
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc3f4
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x90a0
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
callq 0x9710
movq %rbx, %rdi
callq 0x9390
nop
// File: /workspace/github_cpp_makefile_star2_O3/errantlinguist[P]Forecast/src/common/to_string.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> common::to_quoted_string<char>(char const&)
std::string to_quoted_string(const char& value)
{
	std::stringstream ss(std::stringstream::out);

	ss << CHAR_VALUE_DELIMITER;
	ss << value;
	ss << CHAR_VALUE_DELIMITER;

	return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x9220
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x95c0
movb (%r15), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x95c0
leaq 0x7(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x95c0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x91d0
movq 0x2514d(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x2511c(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
movq %rbx, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O3/errantlinguist[P]Forecast/src/common/to_string.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> common::to_quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string to_quoted_string(const std::string& value)
{
	std::stringstream ss(std::stringstream::out);

	ss << STRING_VALUE_DELIMITER;
	ss << value;
	ss << STRING_VALUE_DELIMITER;

	return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x9220
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rsi
movb $0x22, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x95c0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x95c0
leaq 0x7(%rsp), %rsi
movb $0x22, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x95c0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x91d0
movq 0x2508a(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x25059(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
movq %rbx, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O3/errantlinguist[P]Forecast/src/console_weather/ForecastServiceClient.cpp
// Function: console_weather::ForecastServiceClient::get(char const*)
std::unique_ptr<forecast_io::Forecast> ForecastServiceClient::get(const char* url)
{
    // 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 CURLcode responseCode =
        curlClient.read(
            url,
            parseJson, &tokenerParser);

    std::unique_ptr<forecast_io::Forecast> result = nullptr;
    if (CURLE_OK == responseCode)
    {
        result = pForecastFactory->create();
    }
    else
    {
		throw responseCode;
    }
    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 0x8(%rbp), %rsi
movq %rax, %rdi
callq 0x1fb2c
movl $0xa0, %edi
callq 0x90e0
movq %rax, %r14
movq 0x8(%rbp), %rsi
movq %rax, %rdi
callq 0x1f89c
movl $0x348, %edi            # imm = 0x348
callq 0x90e0
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x28bc8
movq (%r12), %rax
movq %r12, %rdi
callq *0x48(%rax)
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x29074
movq (%rbp), %rdi
leaq 0xf5(%rip), %rdx        # 0x1a11f
leaq 0x10(%rsp), %rcx
movl $0x1e, %r8d
movq %r13, %rsi
callq 0x1b926
movl %eax, %ebp
movq $0x0, (%r15)
testl %eax, %eax
jne 0x1a0b1
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 0x1a19e
movq %r13, %rdi
callq 0xc4da
leaq 0x10(%rsp), %rdi
callq 0x2909e
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
movl $0x4, %edi
callq 0x91c0
movl %ebp, (%rax)
leaq 0x230e4(%rip), %rsi     # 0x3d1a8
movq %rax, %rdi
xorl %edx, %edx
callq 0x9370
jmp 0x1a0d0
movq %rax, %r13
movq %r15, %rdi
callq 0xc4da
jmp 0x1a0e0
movq %rax, %r13
leaq 0x10(%rsp), %rdi
callq 0x2909e
jmp 0x1a0f1
jmp 0x1a0ee
movq %rax, %r13
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 %r13, %rdi
callq 0x9390
movq %rax, %r13
jmp 0x1a0fb
movq %rax, %r13
jmp 0x1a104
// File: /workspace/github_cpp_makefile_star2_O3/errantlinguist[P]Forecast/src/console_weather/ForecastServiceClient.cpp
// Function: console_weather::parseJson(char*, unsigned long, unsigned long, void*)
static size_t parseJson(char* readBuffer, size_t size, size_t nmemb,
                        void* pUserData)
{
    size_t result(0);
    if(pUserData)
    {
        json::TokenerParser* const pTokenerParser =
            static_cast<json::TokenerParser*>(pUserData);
        // Calculate the amount of bytes to be parsed
        result = size * nmemb;
        // Check that the size does not overflow as an int type
        if(result <= MAX_PARSER_INPUT_SIZE)
        {
			const int inputSize = static_cast<int>(result);
            pTokenerParser->parse(readBuffer, inputSize);
        }
        else
        {
            throw std::out_of_range("Amount of bytes to read cannot be stored as an int.");
        }

    }

    return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rcx, %rcx
je 0x1a14b
movq %rdx, %rbx
imulq %rsi, %rbx
cmpq $0x7fffffff, %rbx       # imm = 0x7FFFFFFF
ja 0x1a158
movq %rsp, %rsi
movq %rcx, %rdi
movl %ebx, %edx
callq 0x290d4
jmp 0x1a14d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x91c0
movq %rax, %rbx
leaq 0x10fda(%rip), %rsi     # 0x2b146
movq %rax, %rdi
callq 0x9140
movq 0x24dcd(%rip), %rsi     # 0x3ef48
movq 0x24e06(%rip), %rdx     # 0x3ef88
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_O3/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 0x1fb2c
movl $0xa0, %edi
callq 0x90e0
movq %rax, %r14
movq (%rbp), %rsi
movq %rax, %rdi
callq 0x1f89c
movl $0x348, %edi            # imm = 0x348
callq 0x90e0
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x28bc8
movq (%r12), %rax
movq %r12, %rdi
callq *0x48(%rax)
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x29074
movq 0x8(%rbp), %rdx
movl 0x10(%rbp), %ecx
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x2915e
movq $0x0, (%r15)
testq %rax, %rax
jle 0x1a2f0
movq (%r13), %rax
movq -0x18(%rax), %rax
movl 0x20(%r13,%rax), %eax
andl $0x2, %eax
je 0x1a2f0
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 0x1a19e
movq %r13, %rdi
callq 0xc4da
leaq 0x10(%rsp), %rdi
callq 0x2909e
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 0xc4da
jmp 0x1a338
movq %rax, %r13
leaq 0x10(%rsp), %rdi
callq 0x2909e
jmp 0x1a349
jmp 0x1a346
movq %rax, %r13
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
jmp 0x1a358
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 0x1a361
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1424a
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 0x1a40a
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 0x1424a
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x95c0
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a473
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x10dc5(%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 0x1424a
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 0x1a4dd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1a4ef
jmp 0x1a4ef
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a509
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rdi
callq 0x9390
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1aeaa
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 0x10664(%rip), %rsi     # 0x2b433
movl $0x9, %edx
movq %rbx, %rdi
callq 0x95c0
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x9490
movq %rax, %r15
leaq 0x105bb(%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 0x1062c(%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 0x1058c(%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_O3/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 0x1afce
leaq 0x1051f(%rip), %rsi     # 0x2b3e6
movl $0xd, %edx
movq %rbx, %rdi
callq 0x95c0
movsd 0xc8(%r14), %xmm0
movq %rbx, %rdi
callq 0x9490
movq %rax, %r12
leaq 0x104c0(%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 0x104a6(%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_O3/errantlinguist[P]Forecast/src/console_weather/writers/console_writing.cpp
// Function: console_weather::writers::createPaddedHeader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, int)
std::string createPaddedHeader(const std::string& prefix,
		const std::stringstream::char_type paddingSymbol, int resultLength)
{
	const int paddingLength = getPaddingLength(prefix, resultLength);

	std::stringstream ss(std::stringstream::out);
	ss << prefix;
	ss << std::setfill(paddingSymbol) << std::setw(paddingLength) << "";
	return ss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq 0x8(%rsi), %rax
testq $-0x80000000, %rax      # imm = 0x80000000
jne 0x1b6a0
movl %ecx, %ebp
subl %eax, %ebp
jl 0x1b6bf
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x9220
leaq 0x18(%rsp), %r15
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x95c0
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rcx
leaq (%r15,%rcx), %r12
cmpb $0x0, 0xf9(%rsp,%rcx)
jne 0x1b63d
movq %r12, %rdi
movl $0x20, %esi
callq 0x9650
movb $0x1, 0xe1(%r12)
movq 0x18(%rsp), %rax
movb %r14b, 0xe0(%r12)
movq -0x18(%rax), %rax
movslq %ebp, %rcx
movq %rcx, 0x28(%rsp,%rax)
leaq 0xed82(%rip), %rsi      # 0x2a3da
movq %r15, %rdi
xorl %edx, %edx
callq 0x95c0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x91d0
movq 0x2392a(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfdad(%rip), %rdi      # 0x2b454
leaq 0xfdc8(%rip), %rsi      # 0x2b476
leaq 0xfdf1(%rip), %rcx      # 0x2b4a6
movl $0x11, %edx
callq 0x9100
leaq 0xfe29(%rip), %rdi      # 0x2b4ef
leaq 0xfda9(%rip), %rsi      # 0x2b476
leaq 0xfdd2(%rip), %rcx      # 0x2b4a6
movl $0x13, %edx
callq 0x9100
movq %rax, %rbx
movq 0x238b8(%rip), %rsi     # 0x3efa0
leaq 0x8(%rsp), %rdi
callq 0x9470
leaq 0x88(%rsp), %rdi
callq 0x9420
movq %rbx, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21caf(%rip), %rax     # 0x3d4a8
movq %rax, (%rdi)
callq 0x95d0
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
testq %rax, %rax
je 0x1b82e
leaq 0x8(%rbx), %rsi
movq %rbx, %rdi
callq 0x1b860
testl %eax, %eax
jne 0x1b840
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4, %edi
callq 0x91c0
movl $0x2, (%rax)
jmp 0x1b84e
movl %eax, %ebx
movl $0x4, %edi
callq 0x91c0
movl %ebx, (%rax)
leaq 0x21953(%rip), %rsi     # 0x3d1a8
movq %rax, %rdi
xorl %edx, %edx
callq 0x9370
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b899
movq (%rbx), %rdi
movl $0x1, %edx
movl $0x2b, %esi
xorl %eax, %eax
callq 0x94f0
testl %eax, %eax
je 0x1b89b
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_O3/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 0x21bed(%rip), %rax     # 0x3d4a8
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
callq 0x90b0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1b8d5
callq 0x9530
popq %rbx
retq
movq %rax, %rdi
callq 0xc4cf
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b911
movq %rax, 0x18(%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23e8f(%rip), %r14     # 0x3fb50
movq %r14, %rdi
callq 0x1c026
movq %rax, %r15
shlq $0x5, %r15
subq %rax, %r15
leaq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x1c026
addq %r15, %rax
movq %rax, %r15
shlq $0x5, %r15
subq %rax, %r15
leaq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x1c026
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_O3/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 0xf2b5(%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 0x1424a
movq %rsp, %rdi
movq %r15, %rsi
callq 0x19ea3
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x95c0
leaq 0x10(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x1c40a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x90a0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c421
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0xf24c(%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 0x1424a
movq %rsp, %rdi
movq %r15, %rsi
callq 0x19ea3
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x95c0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1c482
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x90a0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c499
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 0x1c4de
jmp 0x1c4f0
jmp 0x1c4ed
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c4f0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x90a0
jmp 0x1c4f0
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c507
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rdi
callq 0x9390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xee7d(%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 0x19f66
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x95c0
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x1c876
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0xee3f(%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 0x19f66
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x95c0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c8c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0xee07(%rip), %rsi      # 0x2b6d6
movl $0xf, %edx
movq %rbx, %rdi
callq 0x95c0
leaq 0x10(%r14), %rsi
leaq 0xee34(%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 0x1c91a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0xedc5(%rip), %rsi      # 0x2b6e6
movl $0x10, %edx
movq %rbx, %rdi
callq 0x95c0
leaq 0x48(%r14), %rsi
leaq 0xede2(%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 0x1c96c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0xed84(%rip), %rsi      # 0x2b6f7
movl $0xd, %edx
movq %rbx, %rdi
callq 0x95c0
movq 0x80(%r14), %rdi
callq 0x1eba0
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 0x1c9c3
jmp 0x1c9c3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1c9dd
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 0x1c9d0
jmp 0x1c9dd
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19ea3
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x95c0
movq 0x221b1(%rip), %rsi     # 0x3fb98
movq 0x221b2(%rip), %rdx     # 0x3fba0
movq %rax, %rdi
callq 0x95c0
movq %rax, %r12
addq $0x20, %r15
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x19ea3
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 0x1da4f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1da6a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x91d0
movq 0x21522(%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 0x1dad0
jmp 0x1dacb
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dad3
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x90a0
jmp 0x1dad3
movq %rax, %rbx
jmp 0x1daee
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1daee
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
movq 0x214ab(%rip), %rsi     # 0x3efa0
leaq 0x50(%rsp), %rdi
callq 0x9470
leaq 0xd0(%rsp), %rdi
callq 0x9420
movq %rbx, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e5f0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x1eace
leaq 0x28(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1eb08
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 0x1e6fa
movq $0x0, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1e4ab
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 0x1e6fa
movq $0x1, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1e4eb
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 0x1e6fa
movq $0x2, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1e52b
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 0x1e6fa
movq $0x3, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1e56b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1e580
jmp 0x1e580
jmp 0x1e580
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1e59a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rdi
callq 0x1e5bc
jmp 0x1e5b4
movq %rax, %r15
movl $0x38, %esi
movq %r14, %rdi
callq 0x90a0
movq %r15, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
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 0x1ebf2
movq %r14, (%rbx)
movq 0x8(%r14), %rdx
leaq 0xcafc(%rip), %rcx      # 0x2b71f
movl $0x11, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x92c0
leaq 0x20(%r14), %rdi
movq 0x28(%r14), %rdx
leaq 0xbc4a(%rip), %rcx      # 0x2a88c
movl $0x2, %r8d
xorl %esi, %esi
callq 0x92c0
leaq 0x40(%r14), %rdi
movq 0x48(%r14), %rdx
leaq 0xcad3(%rip), %rcx      # 0x2b731
movl $0xb, %r8d
xorl %esi, %esi
callq 0x92c0
movq %r14, %rdi
addq $0x60, %rdi
movq 0x68(%r14), %rdx
leaq 0xcac0(%rip), %rcx      # 0x2b73d
movl $0xb, %r8d
xorl %esi, %esi
callq 0x92c0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a814
movq $0x0, (%rbx)
movq %r15, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O3/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 0x211cf
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
jmp 0x211b8
leaq 0x8(%rsp), %rdi
callq 0x1c042
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1c042
movq %rbx, %rdi
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21344
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 0x21320
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_O3/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 0x2336e
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 0x92c2(%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 0x22ef6
movl $0x0, (%rax)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x22d8e
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 0x22ef6
movl $0x1, (%rax)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x22de3
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 0x22ef6
movl $0x2, (%rax)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x22e2a
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 0x22ef6
movl $0x3, (%rax)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x22e6c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x22e81
jmp 0x22e81
jmp 0x22e81
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x22ea0
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x90a0
jmp 0x22ea0
movq %rax, %r15
movq %rbx, %rdi
callq 0x22ec2
movq %r15, %rdi
callq 0x9390
movq %rax, %r15
movl $0x38, %esi
movq %r14, %rdi
callq 0x90a0
jmp 0x22ea8
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2359a
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 0x2353d
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
jmp 0x23526
leaq 0x1a02c(%rip), %rax     # 0x3d570
addq $0x10, %rax
leaq 0x48(%rsp), %rdi
movq %rax, -0x48(%rdi)
callq 0xc7d2
leaq 0x10(%rsp), %rdi
callq 0xc8a6
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x19ffb(%rip), %rax     # 0x3d570
addq $0x10, %rax
leaq 0x48(%rsp), %rdi
movq %rax, -0x48(%rdi)
callq 0xc7d2
leaq 0x10(%rsp), %rdi
callq 0xc8a6
movq %rbx, %rdi
callq 0x9390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq $0x0, 0x10(%rsp)
movq (%rsi), %rdi
callq 0x9110
movq 0x8(%rax), %rbp
testq %rbp, %rbp
je 0x2361f
leaq 0x28(%rsp), %r13
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %r15
leaq 0x10(%rsp), %r12
movq (%rbp), %rsi
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rbp), %rbp
movq %r14, %rdi
movq %r15, %rdx
callq 0xc40a
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x23d94
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x2361a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x90a0
testq %rbp, %rbp
jne 0x235d9
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
cmpq %r13, %rdi
je 0x23651
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x90a0
movq %rbx, %rdi
callq 0x9390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23de2
testq %rax, %rax
je 0x23dcb
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_O3/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 0x7ff4(%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 0x81d2(%rip), %rsi      # 0x2c310
movl $0x7, %edx
movq %rax, %rdi
callq 0x95c0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x24c84
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x95c0
leaq 0x7fb4(%rip), %rsi      # 0x2c122
movl $0xc, %edx
movq %rax, %rdi
callq 0x95c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24196
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x90a0
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x91d0
movq 0x1adf6(%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 0x241f5
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x241f8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x90a0
jmp 0x241f8
movq %rax, %rbx
movq 0x1ada1(%rip), %rsi     # 0x3efa0
leaq 0x20(%rsp), %rdi
callq 0x9470
leaq 0xa0(%rsp), %rdi
callq 0x9420
movq %rbx, %rdi
callq 0x9390