LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/querymain.cc
// Function: main
int main(int argc, char **argv)
{
    // open the file from which user will query words
    ifstream infile;
	// open returns void, so we use the comma operator XREF(commaOp)
	// to check the state of infile after the open
    if (argc < 2 || !(infile.open(argv[1]), infile)) {
        cerr << "No input file!" << endl;
        return EXIT_FAILURE;
    }
	runQueries(infile);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movl %edi, %r14d
leaq -0x218(%rbp), %rdi
callq 0x21d0
cmpl $0x2, %r14d
jl 0x259b
movq 0x8(%rbx), %rsi
leaq -0x218(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2100
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
je 0x25d3
movq 0x4a4e(%rip), %rdi      # 0x6ff0
leaq 0x1a84(%rip), %rsi      # 0x402d
callq 0x2190
movq %rax, %rdi
callq 0x20e0
pushq $0x1
popq %rbx
leaq -0x218(%rbp), %rdi
callq 0x2060
movl %ebx, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebx, %ebx
leaq -0x218(%rbp), %rdi
callq 0x242c
jmp 0x25b9
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/errantlinguist[P]Forecast/src/main.cpp
// Function: createJsonParseErrorMessage[abi:cxx11](std::exception const&)
static std::string createJsonParseErrorMessage(const std::exception& e)
{
	std::stringstream errorMessage(std::stringstream::out);
	errorMessage << "There was an error parsing the server response as JSON: ";
	errorMessage << e.what() << std::endl;
	return errorMessage.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
pushq $0x10
popq %rsi
callq 0x9250
leaq 0x18(%rsp), %r15
leaq 0x1719b(%rip), %rsi     # 0x22167
movq %r15, %rdi
callq 0x9360
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x9360
movq %rax, %rdi
callq 0x9610
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x91f0
leaq 0x8(%rsp), %rdi
callq 0x91d0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x91d0
movq %rbx, %rdi
callq 0x93b0
// File: /workspace/github_cpp_makefile_star2_O2/errantlinguist[P]Forecast/src/main.cpp
// Function: printCurlErrorMessage(char const* const&)
static void printCurlErrorMessage(const char* const& pCurlErrorMessage)
{
	if (std::strcmp(pCurlErrorMessage, "") == 0)
	{
		std::cerr << DEFAULT_URL_GETTER_ERROR_MESSAGE << std::endl;
	} else
	{
		std::cerr << "An error occurred while getting the given URL: " << pCurlErrorMessage << std::endl;
	}
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
cmpb $0x0, (%rax)
je 0xb053
movq %rdi, %rbx
movq 0x2df81(%rip), %rdi     # 0x38fc0
leaq 0x171b6(%rip), %rsi     # 0x221fc
callq 0x9360
movq (%rbx), %rsi
movq %rax, %rdi
jmp 0xb061
movq 0x2df66(%rip), %rdi     # 0x38fc0
leaq 0x170d7(%rip), %rsi     # 0x22138
callq 0x9360
movq %rax, %rdi
popq %rbx
jmp 0x9610
nop
// File: /workspace/github_cpp_makefile_star2_O2/errantlinguist[P]Forecast/src/common/TimeWriter.cpp
// Function: common::TimeWriter::write(tm const*, std::ostream&)
void TimeWriter::write(const struct tm* value, std::ostream& output)
{
	std::unique_ptr<char[]> pBuffer(new char[maxLength]);
	char* const rawpBuffer = pBuffer.get();
	std::strftime(rawpBuffer, maxLength, format, value);
	output << rawpBuffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %r12
movq %r12, %rdi
callq 0x9280
movq %rax, %r13
movq %rax, 0x8(%rsp)
movq 0x8(%r15), %rdx
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x9540
movq %rbx, %rdi
movq %r13, %rsi
callq 0x9360
leaq 0x8(%rsp), %rdi
callq 0xb54a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb54a
movq %rbx, %rdi
callq 0x93b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x10
popq %rsi
callq 0x9250
leaq 0x18(%rsp), %r14
pushq $0x27
popq %rsi
movq %r14, %rdi
callq 0x93e0
movsbl (%r15), %esi
movq %r14, %rdi
callq 0x93e0
pushq $0x27
popq %rsi
movq %r14, %rdi
callq 0x93e0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x91f0
leaq 0x8(%rsp), %rdi
callq 0x91d0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x91d0
movq %rbx, %rdi
callq 0x93b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x10
popq %rsi
callq 0x9250
leaq 0x18(%rsp), %r14
pushq $0x22
popq %rsi
movq %r14, %rdi
callq 0x93e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x9170
pushq $0x22
popq %rsi
movq %r14, %rdi
callq 0x93e0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x91f0
leaq 0x8(%rsp), %rdi
callq 0x91d0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x91d0
movq %rbx, %rdi
callq 0x93b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x78
popq %rdi
callq 0x90e0
movq %rax, %rbx
movq 0x8(%rbp), %rsi
movq %rax, %rdi
callq 0x194ec
movl $0xa0, %edi
callq 0x90e0
movq %rax, %r14
movq 0x8(%rbp), %rsi
movq %rax, %rdi
callq 0x193a0
movl $0x348, %edi            # imm = 0x348
callq 0x90e0
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20bcc
movq (%r12), %rax
movq %r12, %rdi
callq *0x48(%rax)
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x20f1c
movq (%rbp), %rdi
leaq 0xeb(%rip), %rdx        # 0x15237
leaq 0x10(%rsp), %rcx
pushq $0x1e
popq %r8
movq %r13, %rsi
callq 0x163d0
movl %eax, %ebp
andq $0x0, (%r15)
testl %eax, %eax
jne 0x151cb
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x10(%rax)
leaq 0x8(%rsp), %r13
movq (%r13), %rsi
andq $0x0, (%r13)
movq %r15, %rdi
callq 0x152b4
movq %r13, %rdi
callq 0xb138
leaq 0x10(%rsp), %rdi
callq 0x20f46
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
pushq $0x4
popq %rdi
callq 0x91e0
movl %ebp, (%rax)
leaq 0x21fcc(%rip), %rsi     # 0x371a8
movq %rax, %rdi
xorl %edx, %edx
callq 0x9390
jmp 0x151e8
movq %rax, %r13
movq %r15, %rdi
callq 0xb138
jmp 0x151f8
movq %rax, %r13
leaq 0x10(%rsp), %rdi
callq 0x20f46
jmp 0x15209
jmp 0x15206
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 0x93b0
movq %rax, %r13
jmp 0x15213
movq %rax, %r13
jmp 0x1521c
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15263
movq %rdx, %rbx
imulq %rsi, %rbx
cmpq $0x7fffffff, %rbx       # imm = 0x7FFFFFFF
ja 0x15270
movq %rsp, %rsi
movq %rcx, %rdi
movl %ebx, %edx
callq 0x20f7a
jmp 0x15265
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x91e0
movq %rax, %rbx
leaq 0xde0c(%rip), %rsi      # 0x2308e
movq %rax, %rdi
callq 0x9140
movq 0x23cc7(%rip), %rsi     # 0x38f58
movq 0x23d00(%rip), %rdx     # 0x38f98
movq %rbx, %rdi
callq 0x9390
movq %rax, %r14
movq %rbx, %rdi
callq 0x9530
movq %r14, %rdi
callq 0x93b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x78
popq %rdi
callq 0x90e0
movq %rax, %rbx
movq (%rbp), %rsi
movq %rax, %rdi
callq 0x194ec
movl $0xa0, %edi
callq 0x90e0
movq %rax, %r14
movq (%rbp), %rsi
movq %rax, %rdi
callq 0x193a0
movl $0x348, %edi            # imm = 0x348
callq 0x90e0
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20bcc
movq (%r12), %rax
movq %r12, %rdi
callq *0x48(%rax)
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x20f1c
movq 0x8(%rbp), %rdx
movl 0x10(%rbp), %ecx
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x21002
andq $0x0, (%r15)
testq %rax, %rax
jle 0x153ea
movq (%r13), %rax
movq -0x18(%rax), %rax
movl 0x20(%r13,%rax), %eax
andl $0x2, %eax
je 0x153ea
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x10(%rax)
leaq 0x8(%rsp), %r13
movq (%r13), %rsi
andq $0x0, (%r13)
movq %r15, %rdi
callq 0x152b4
movq %r13, %rdi
callq 0xb138
leaq 0x10(%rsp), %rdi
callq 0x20f46
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 0xb138
jmp 0x15432
movq %rax, %r13
leaq 0x10(%rsp), %rdi
callq 0x20f46
jmp 0x15443
jmp 0x15440
movq %rax, %r13
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
jmp 0x15452
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 0x93b0
movq %rax, %r13
jmp 0x1545b
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
addq $0x8, %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x9330
movq %r14, %rdi
movq %r12, %rsi
callq 0x9170
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x93e0
leaq 0x8(%rsp), %rdi
callq 0x9710
movq %r14, %rdi
movq %r15, %rsi
callq 0x9170
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x93e0
leaq 0x30(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x9330
movq %r14, %rdi
movq %r15, %rsi
callq 0x9170
leaq 0x8(%rsp), %rdi
callq 0x9710
leaq 0xdc6d(%rip), %rsi      # 0x23187
movq %r14, %rdi
callq 0x9360
movq %rax, %r14
addq $0x50, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9330
movq %r14, %rdi
movq %r15, %rsi
callq 0x9170
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x93e0
leaq 0x8(%rsp), %rdi
callq 0x9710
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x15569
jmp 0x15569
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9710
movq %rbx, %rdi
callq 0x93b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/errantlinguist[P]Forecast/src/console_weather/writers/ForecastConsoleWriter.cpp
// Function: console_weather::writers::ForecastConsoleWriter::write(forecast_io::Forecast const&, std::ostream&)
void ForecastConsoleWriter::write(const forecast_io::Forecast& value, std::ostream& output)
{
	output << "Forecast for location at coordinates ";
	// FIXME: The coordinate values are always zero here
	const math::Coordinate location = value.getLocation();
	output << location << '\n';

	output << headerRowSeparator << '\n';

	// Timezone and offset
	const std::string timezone = value.getTimezone();
	output << "Timezone: \"" << timezone << "\" (Offset: ";
	const short offsetNumericValue = static_cast<const short>(value.getOffset());
	output << offsetNumericValue;
	output << " hrs.)\n";

	// Alerts
	const std::vector<forecast_io::Alert>& alerts = value.getAlerts();
	if (!alerts.empty())
	{
		output << alertsSectionHeader << '\n';
		write(alerts, output);
	}

	// Current forecast data
	output << currentWeatherSectionHeader << '\n';
	const forecast_io::SynchronicDataPoint& currentWeather = value.getCurrentWeather();
	synchronicDataPointWriter.write(currentWeather, output);
	output << '\n';

	// Flags
	output << flagsSectionHeader << '\n';
	flagsWriter.write(value.getFlags(), output);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xd92c(%rip), %rsi      # 0x23262
movq %rdx, %rdi
callq 0x9360
leaq 0x23343(%rip), %rax     # 0x38c88
addq $0x10, %rax
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movups 0xa8(%r14), %xmm0
movups %xmm0, 0x8(%rsi)
movq %rbx, %rdi
callq 0x21304
pushq $0xa
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x93e0
leaq 0x120(%r15), %rsi
movq %rbx, %rdi
callq 0x9170
movq %rax, %rdi
movl %ebp, %esi
callq 0x93e0
leaq 0xc0(%r14), %rsi
movq %rsp, %rdi
callq 0x9330
leaq 0xd8e7(%rip), %rsi      # 0x23288
movq %rbx, %rdi
callq 0x9360
movq %rsp, %rsi
movq %rax, %rdi
callq 0x9170
leaq 0xd8d9(%rip), %rsi      # 0x23294
movq %rax, %rdi
callq 0x9360
movsbl 0xb8(%r14), %esi
movq %rbx, %rdi
callq 0x92f0
leaq 0xd8c6(%rip), %rsi      # 0x232a0
movq %rbx, %rdi
callq 0x9360
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x15a13
leaq 0xc0(%r15), %rsi
movq %rbx, %rdi
callq 0x9170
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x93e0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x15aa8
leaq 0xe0(%r15), %rsi
movq %rbx, %rdi
callq 0x9170
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x93e0
leaq 0xe0(%r14), %rsi
leaq 0x28(%r15), %rdi
movq %rbx, %rdx
callq 0x15bc8
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x93e0
leaq 0x100(%r15), %rsi
movq %rbx, %rdi
callq 0x9170
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x93e0
addq $0x20, %r15
addq $0x18, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x15580
movq %rsp, %rdi
callq 0x9710
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15a94
jmp 0x15a94
jmp 0x15a94
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9710
movq %rbx, %rdi
callq 0x93b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15cb2
movsd 0xd8(%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xe0(%r15), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x9170
pushq $0xa
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x93e0
leaq 0xd75d(%rip), %rsi      # 0x2337b
movq %rbx, %rdi
callq 0x9360
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x94b0
leaq 0xd6bc(%rip), %rsi      # 0x232f7
movq %rax, %rdi
callq 0x9360
movq %rax, %rdi
movl %ebp, %esi
callq 0x93e0
leaq 0xd73d(%rip), %rsi      # 0x23391
movq %rbx, %rdi
callq 0x9360
movq %rax, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x94b0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x93e0
leaq 0xd6af(%rip), %rsi      # 0x2332b
movq %rax, %rdi
callq 0x9360
movq %rax, %rdi
movl %ebp, %esi
callq 0x93e0
addq $0x18, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9170
movq %rax, %rdi
movl %ebp, %esi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x93e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rsi, %rbx
callq 0x15d7c
leaq 0xd65f(%rip), %rsi      # 0x2332e
movq %r14, %rdi
callq 0x9360
movsd 0xc8(%rbx), %xmm0
movq %rax, %rdi
callq 0x94b0
leaq 0xd609(%rip), %r15      # 0x232f7
movq %rax, %rdi
movq %r15, %rsi
callq 0x9360
pushq $0x20
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x93e0
pushq $0x46
popq %r12
movq %rax, %rdi
movl %r12d, %esi
callq 0x93e0
pushq $0xa
popq %r13
movq %rax, %rdi
movl %r13d, %esi
callq 0x93e0
leaq 0xd611(%rip), %rsi      # 0x2333c
movq %r14, %rdi
callq 0x9360
movsd 0xd0(%rbx), %xmm0
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x9360
movq %rax, %rdi
movl %ebp, %esi
callq 0x93e0
movq %rax, %rdi
movl %r12d, %esi
callq 0x93e0
movq %rax, %rdi
movl %r13d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x93e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21203(%rip), %rax     # 0x374b8
movq %rax, (%rdi)
callq 0x95d0
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
testq %rax, %rax
je 0x162e7
leaq 0x8(%rbx), %rsi
movq %rbx, %rdi
callq 0x16314
testl %eax, %eax
jne 0x162f7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x4
popq %rdi
callq 0x91e0
movl $0x2, (%rax)
jmp 0x16303
movl %eax, %ebx
pushq $0x4
popq %rdi
callq 0x91e0
movl %ebx, (%rax)
leaq 0x20e9e(%rip), %rsi     # 0x371a8
movq %rax, %rdi
xorl %edx, %edx
callq 0x9390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9510
testl %eax, %eax
jne 0x16349
movq (%rbx), %rdi
pushq $0x2b
popq %rsi
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0x9510
testl %eax, %eax
je 0x1634b
popq %rbx
retq
movq (%rbx), %rdi
pushq $0x34
popq %rsi
pushq $0x1
popq %rdx
xorl %eax, %eax
popq %rbx
jmp 0x9510
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21151(%rip), %rax     # 0x374b8
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
callq 0x90b0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x16381
callq 0x9550
popq %rbx
retq
movq %rax, %rdi
callq 0xb12c
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x93c0
testq %rax, %rax
je 0x163bb
movq %rax, 0x18(%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9510
testl %eax, %eax
jne 0x1643d
movq 0x8(%rbx), %rdi
movl $0x2711, %esi           # imm = 0x2711
movq %r12, %rdx
xorl %eax, %eax
callq 0x9510
testl %eax, %eax
jne 0x1643d
movq 0x8(%rbx), %rdi
pushq $0xd
popq %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x9510
testl %eax, %eax
jne 0x1643d
movq 0x8(%rbx), %rdi
xorl %ebp, %ebp
movl $0x2712, %esi           # imm = 0x2712
movq %r14, %rdx
xorl %eax, %eax
callq 0x9510
testl %eax, %eax
je 0x1644a
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 0x1643f
movq 0x8(%rbx), %rdi
movl $0x2727, %esi           # imm = 0x2727
xorl %eax, %eax
callq 0x9510
testl %eax, %eax
jne 0x1643d
movq 0x8(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x93f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2346d(%rip), %r14     # 0x39b50
movq %r14, %rdi
callq 0x1690e
imulq $0x1f, %rax, %r15
leaq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x1690e
addq %r15, %rax
imulq $0x1f, %rax, %r15
leaq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x1690e
addq %r15, %rax
imulq $0x1f, %rax, %rax
movq 0x28(%rbx), %rcx
addq %rcx, %rax
addq $0xe1781, %rax          # imm = 0xE1781
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/errantlinguist[P]Forecast/src/forecast_io/Alert.cpp
// Function: forecast_io::Alert::dump(std::ostream&) const
std::ostream& Alert::dump(std::ostream& o) const
{
	o << "Alert[getTitle()=";
	o << common::to_quoted_string(getTitle());
	o << ", getExpiryTime()=";
	o << common::to_quoted_string(getExpiryTime());
	o << ", getDescription()=";
	o << common::to_quoted_string(getDescription());
	o << ", getUri()=";
	o << common::to_quoted_string(getUri());
	o << ']';

	return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xcd32(%rip), %rsi      # 0x23470
movq %rbx, %rdi
callq 0x9360
leaq 0x8(%r14), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x9330
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1500a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9170
movq %rsp, %rdi
callq 0x9710
leaq 0x20(%rsp), %rdi
callq 0x9710
leaq 0xccfc(%rip), %rsi      # 0x23482
movq %rbx, %rdi
callq 0x9360
movq 0x28(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x169c7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9170
movq %rsp, %rdi
callq 0x9710
leaq 0xccde(%rip), %rsi      # 0x23495
movq %rbx, %rdi
callq 0x9360
leaq 0x30(%r14), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x9330
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1500a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9170
movq %rsp, %rdi
callq 0x9710
leaq 0x20(%rsp), %rdi
callq 0x9710
leaq 0xccaa(%rip), %rsi      # 0x234a9
movq %rbx, %rdi
callq 0x9360
addq $0x50, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x9330
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1500a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9170
movq %rsp, %rdi
callq 0x9710
leaq 0x20(%rsp), %rdi
callq 0x9710
pushq $0x5d
popq %rsi
movq %rbx, %rdi
callq 0x93e0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1686b
jmp 0x16878
jmp 0x1686b
jmp 0x16878
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x16880
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9710
jmp 0x1687b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9710
movq %rbx, %rdi
callq 0x93b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xca23(%rip), %rsi      # 0x23599
movq %rbx, %rdi
callq 0x9360
leaq 0x8(%r14), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x9330
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1500a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9170
movq %rsp, %rdi
callq 0x9710
leaq 0x20(%rsp), %rdi
callq 0x9710
leaq 0xc9f6(%rip), %rsi      # 0x235b4
movq %rbx, %rdi
callq 0x9360
addq $0x28, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x9330
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1500a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9170
movq %rsp, %rdi
callq 0x9710
leaq 0x20(%rsp), %rdi
callq 0x9710
pushq $0x5d
popq %rsi
movq %rbx, %rdi
callq 0x93e0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x16c1e
jmp 0x16c2b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9710
jmp 0x16c2e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9710
movq %rbx, %rdi
callq 0x93b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc747(%rip), %rsi      # 0x235e3
movq %rbx, %rdi
callq 0x9360
movb 0x9(%r14), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x1508b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9170
leaq 0x10(%rsp), %rdi
callq 0x9710
leaq 0xc724(%rip), %rsi      # 0x235fc
movq %rbx, %rdi
callq 0x9360
movb 0x8(%r14), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x1508b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9170
leaq 0x10(%rsp), %rdi
callq 0x9710
leaq 0xc702(%rip), %rsi      # 0x23616
movq %rbx, %rdi
callq 0x9360
leaq 0x10(%r14), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x17050
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9170
leaq 0x10(%rsp), %rdi
callq 0x9710
leaq 0xc6dd(%rip), %rsi      # 0x23626
movq %rbx, %rdi
callq 0x9360
leaq 0x48(%r14), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x17065
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9170
leaq 0x10(%rsp), %rdi
callq 0x9710
leaq 0xc6b9(%rip), %rsi      # 0x23637
movq %rbx, %rdi
callq 0x9360
movq 0x80(%r14), %rdi
callq 0x18bf8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9170
pushq $0x5d
popq %rsi
movq %rbx, %rdi
callq 0x93e0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x16fbb
jmp 0x16fbb
jmp 0x16fbb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9710
movq %rbx, %rdi
callq 0x93b0
// File: /workspace/github_cpp_makefile_star2_O2/errantlinguist[P]Forecast/include/common/to_string.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> common::to_collection_string<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>>>>, char, 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>>>> const&, std::pair<char, char> const&)
std::string to_collection_string(const C& value,
		const std::pair<LD, RD>& delimiters)
{
	std::stringstream ss(std::stringstream::out);
	ss << delimiters.first;

	auto iter = value.cbegin();
	if (iter != value.cend())
	{
		const std::string firstElementStr(to_quoted_string(*iter));
		ss << firstElementStr;	// Print the first element
		++iter;					// Increment to next element
	}
	for (; iter != value.cend(); ++iter)
	{
		const std::string nextElementStr(to_quoted_string(*iter));
		ss << nextElementStr;					// Print the next element
		ss << SEQUENCE_ELEMENT_SEPARATOR;	// Print separator
	}

	ss << delimiters.second;
	return ss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rsi
callq 0x9250
leaq 0x30(%rsp), %r15
movsbl (%r14), %esi
movq %r15, %rdi
callq 0x93e0
movq 0x10(%r12), %r12
testq %r12, %r12
je 0x17b5d
leaq 0x8(%r12), %rsi
movq %rsp, %rdi
callq 0x1500a
movq %rsp, %rsi
movq %r15, %rdi
callq 0x9170
movq (%r12), %rbp
movq %rsp, %rdi
callq 0x9710
jmp 0x17b5f
xorl %ebp, %ebp
movq %rsp, %r12
leaq 0x2202f(%rip), %r13     # 0x39b98
testq %rbp, %rbp
je 0x17b9e
leaq 0x8(%rbp), %rsi
movq %r12, %rdi
callq 0x1500a
movq %r15, %rdi
movq %r12, %rsi
callq 0x9170
movq %r15, %rdi
movq %r13, %rsi
callq 0x9170
movq %r12, %rdi
callq 0x9710
movq (%rbp), %rbp
jmp 0x17b69
movsbl 0x1(%r14), %esi
movq %r15, %rdi
callq 0x93e0
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x91f0
leaq 0x20(%rsp), %rdi
callq 0x91d0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17be4
jmp 0x17bdf
jmp 0x17bdf
jmp 0x17bdf
movq %rax, %rbx
jmp 0x17bef
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9710
leaq 0x20(%rsp), %rdi
callq 0x91d0
movq %rbx, %rdi
callq 0x93b0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x1c8, %rsp            # imm = 0x1C8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
pushq $0x10
popq %rsi
callq 0x9250
leaq 0x50(%rsp), %rdi
movsbl (%r14), %esi
callq 0x93e0
movq %rax, %r12
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x1500a
leaq 0x20(%rsp), %rsi
movq %r12, %rdi
callq 0x9170
leaq 0x21e20(%rip), %rsi     # 0x39b98
movq %rax, %rdi
callq 0x9170
movq %rax, %r12
addq $0x20, %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1500a
movq %rsp, %rsi
movq %r12, %rdi
callq 0x9170
movsbl 0x1(%r14), %esi
movq %rax, %rdi
callq 0x93e0
movq %rsp, %rdi
callq 0x9710
leaq 0x20(%rsp), %rdi
callq 0x9710
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0x91f0
leaq 0x40(%rsp), %rdi
callq 0x91d0
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x17dfb
jmp 0x17df6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9710
jmp 0x17dfe
movq %rax, %rbx
jmp 0x17e08
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9710
leaq 0x40(%rsp), %rdi
callq 0x91d0
movq %rbx, %rdi
callq 0x93b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1862c
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x18b62
leaq 0x28(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0x90e0
movq %rax, %r14
pushq $0x4
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0xe(%rsp), %rcx
leaq 0xf(%rsp), %r8
movq %rax, %rdi
callq 0x18b90
movq %r14, (%rbx)
leaq 0xb15e(%rip), %rsi      # 0x2365f
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xb070
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x18760
andq $0x0, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x9710
leaq 0xb130(%rip), %rsi      # 0x23662
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xb070
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x18760
movq $0x1, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x9710
leaq 0xb0ff(%rip), %rsi      # 0x23665
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xb070
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x18760
movq $0x2, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x9710
leaq 0xb0ce(%rip), %rsi      # 0x23668
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xb070
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x18760
movq $0x3, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x9710
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x185e0
jmp 0x185ef
jmp 0x185e0
jmp 0x185ef
jmp 0x185e0
jmp 0x185ef
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x9710
jmp 0x185f2
movq %rax, %r15
movq %rbx, %rdi
callq 0x18612
movq %r15, %rdi
callq 0x93b0
movq %rax, %r15
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x90a0
jmp 0x185fa
// File: /workspace/github_cpp_makefile_star2_O2/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)
movq %rax, %rdi
callq 0x18cb0
movq %r14, (%rbx)
leaq 0xaa15(%rip), %rsi      # 0x2366b
movq %r14, %rdi
callq 0x96e0
leaq 0x20(%r14), %rdi
leaq 0x9b6f(%rip), %rsi      # 0x227d8
callq 0x96e0
leaq 0x40(%r14), %rdi
leaq 0xaa04(%rip), %rsi      # 0x2367d
callq 0x96e0
addq $0x60, %r14
leaq 0xaa00(%rip), %rsi      # 0x23689
movq %r14, %rdi
callq 0x96e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15796
movq %r14, %rdi
callq 0x93b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a249
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
jmp 0x1a232
leaq 0x8(%rsp), %rdi
callq 0x1692a
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1692a
movq %rbx, %rdi
callq 0x93b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9270
movq %rax, %r15
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
leaq 0x8(%rsp), %r13
cmpq %r12, %r15
je 0x1a365
movq (%r14), %rdi
movq %r12, %rsi
callq 0x9570
movq %rax, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
callq *0x28(%rax)
incq %r12
jmp 0x1a33f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0x90e0
movq %rax, %r14
pushq $0x4
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0xe(%rsp), %rcx
leaq 0xf(%rsp), %r8
movq %rax, %rdi
callq 0x1c012
movq %r14, (%rbx)
leaq 0x8578(%rip), %rsi      # 0x23f87
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xb070
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x1bb36
andl $0x0, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x9710
leaq 0x855c(%rip), %rsi      # 0x23f9b
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xb070
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x1bb36
movl $0x1, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x9710
leaq 0x8537(%rip), %rsi      # 0x23fa9
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xb070
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x1bb36
movl $0x2, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x9710
leaq 0x850c(%rip), %rsi      # 0x23fb1
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xb070
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x1bb36
movl $0x3, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x9710
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1baea
jmp 0x1baf9
jmp 0x1baea
jmp 0x1baf9
jmp 0x1baea
jmp 0x1baf9
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x9710
jmp 0x1bafc
movq %rax, %r15
movq %rbx, %rdi
callq 0x1bb1c
movq %r15, %rdi
callq 0x93b0
movq %rax, %r15
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x90a0
jmp 0x1bb04
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c1b6
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 0x1c18f
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
jmp 0x1c178
movq %rsp, %rdi
callq 0xb240
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb240
movq %rbx, %rdi
callq 0x93b0
nop