Invalid linker library in README.md for compiling MLIR -> native about cairo_native HOT 4 CLOSED

// wrapper.c
#include <stdint.h>

extern void alias_example_main(int64_t, __int128);

int main() {
    int64_t arg0 = 0;
    __int128 arg1 = 0;
    alias_example_main(arg0, arg1);
    return 0;
}

#include <stdio.h>
#include <stdint.h>


// Type consistency.
typedef __uint128_t uint128_t;


// Cairo Native types.
typedef struct __attribute__((aligned(16))) felt252_t
{
    uint64_t data[4];
} felt252_t;

typedef struct native_array_t
{
    void *data;
    uint32_t start_offset;
    uint32_t end_offset;
    uint32_t capacity;
} native_array_t;


// Our function's return values (check out the C ABI for more info).
typedef struct cairo_main_t
{
    uint64_t range_check;
    uint128_t gas;
    union {
        struct { uint8_t tag; uint32_t value; } ok;
        struct { uint8_t tag; native_array_t msg; } err;
    } result;
} cairo_main_t;


// The weakref is the symbol name. You should make sure it matches the one in the MLIR output,
// including the `_mlir_ciface_` prefix.
static cairo_main_t *cairo_main(cairo_main_t *, uint64_t, uint128_t)
    __attribute__((weakref("_mlir_ciface_program::program::main(f0)")));


int main()
{
    cairo_main_t ret_data;

    // You don't need to initialize the range check and gas into the return pointer, you can pass
    // them directly too. The final builtin counter and gas will be stored in the structure, so
    // having them originally there may make it easier to understand.
    ret_data.range_check = 0;
    ret_data.gas = 1000000000000;
    cairo_main(&ret_data, ret_data.range_check, ret_data.gas);

    // You can check either `ret_data.ok.tag` or `ret_data.err.tag`. They are the same field, but
    // must be declared separately in each variant due to the way our enums work (if it was a common
    // field, then the alignment of the payloads would be messed up).
    if (ret_data.result.ok.tag == 0)
        printf("cairo_main() returned Ok(%u)\n", ret_data.result.ok.value);
    else
    {
        felt252_t *error_msg = (felt252_t *) ret_data.result.err.msg.data;
        size_t i;

        // Here's an example on how to read the arrays (for the error messages):
        printf("cairo_main() returned an error:\n");
        for (i = ret_data.result.err.msg.start_offset; i < ret_data.result.err.msg.end_offset; i++)
        {
            // Note that they're in reverse order. It's intentional because they're written in
            // little-endian.
            printf(
                "  %016lx%016lx%016lx%016lx\n",
                error_msg[i].data[3],
                error_msg[i].data[2],
                error_msg[i].data[1],
                error_msg[i].data[0]
            );
        }
    }

    return  0;
}