ambiguous overload for 'operator<<' (operand types are 'std::ostream' {aka 'std::basic_ostream<char>'} and '__int128') win MinGW

I am trying to compile the following code with MinGW (x86_64-13.1.0-release-win32-seh-msvcrt-rt_v11-rev1):

#include <iostream>

void f()
{
    __int128_t val = 1;
    
    std::cout << val;
}

and getting the following compiler error:

error: ambiguous overload for 'operator<<' (operand types are 'std::ostream' {aka 'std::basic_ostream<char>'} and '__int128')
[build]    16 |         std::cout << val;
[build]       |         ~~~~~~~~~ ^~ ~~~
[build]       |              |       |
[build]       |              |       __int128
[build]       |              std::ostream {aka std::basic_ostream<char>}error: ambiguous overload for 'operator<<' (operand types are 'std::ostream' {aka 'std::basic_ostream<char>'} and '__int128')
[build]    16 |         std::cout << val;
[build]       |         ~~~~~~~~~ ^~ ~~~
[build]       |              |       |
[build]       |              |       __int128
[build]       |              std::ostream {aka std::basic_ostream<char>}

Why is it ambiguous?

EDIT1

The same error with GCC in online compilers.

EDIT2

The same result with the following code:

void f1 (uint64_t val) {}
void f1 (int32_t val) {}

void f()
{
    __int128_t val = 1;
    
    f1(val);
}

The error means that there are no overload of operator<< exactly for __int128_t, which is not mentioned in standard and which is not cross-platform, it is specific to the GCC compiler.

For this reason, the compiler tries to implicitly convert the value to other types like int, unsigned int, long, etc. As a result, this conversion causes ambiguity, because there are many types to which it is possible to convert __int128_t, and there are multiple operator overloads for those types.

As far as I know, the only way to print __int128_t is to write your own operator overload. Here is a link for another question, where you can find code snippets for creating such an overload. One of the possible variants (copied from the answer in the given link) looks like this:

std::ostream& operator<<(std::ostream& o, const __int128_t& x) {
    if (x == std::numeric_limits<__int128_t>::min()) return o << "-170141183460469231731687303715884105728";
    if (x < 0) return o << "-" << -x;
    if (x < 10) return o << (char)(x + '0');
    return o << x / 10 << (char)(x % 10 + '0');
}

But, if in your code you have to use such big numbers, it is better to use cross-platform libraries, not compiler-specific types. For example, you can use a BigInt library for usage of arbitrary-sized integers.

Write your own operator to do the conversion and printing.

#include <iostream>
#include <algorithm>
#include <limits>

std::ostream& operator << (std::ostream& os, __int128_t val)
{
    std::string result;
    bool is_negative = val < 0;
    if (is_negative)
    {
        val *= -1;
    }

    do
    {
        result.push_back((val % 10) + '0');
        val /= 10;
    }
    while (val != 0);

    if (is_negative)
    {
        result.push_back('-');
    }

    std::reverse(result.begin(), result.end());
    return (os << result);
}

int main()
{
    __int128_t val = std::numeric_limits<int64_t>::max();
    
    std::cout << (val * 900000);
    return 0;
}