Как написать функцию выделения памяти?

#include <iostream>
#include <new>
#include <cstddef>
 
// где-то когда-то
alignas(double) char BSS[1000]; 
 
alignas(double) int  values[ ]{ 1, 2, 3, 4, 5, 6, 7, 8 };
 
alignas(double) const std::int64_t cvalues{ 1ll << (64 - 2), }; 
 
int 
main()
{
    const auto 
        newd { new(reinterpret_cast<void*>(&main))  double, }, // плохо!
        newc { new(const_cast<std::int64_t*>(&cvalues))     double, } // в области для инициализированных констант
        ;
 
        auto 
        // в области для инициализированных int
        initialized { new(values)   double{7.6543,} }, 
        // в области для неинициализированных char
        uninitialized { new(BSS)    double{6.543e-3,} }; 
 
    
    std::cout 
        << *newd << " at " << newd << '\n' 
        << *newc << " at " << newc << '\n' 
        << *initialized << " at " << initialized << '\n' 
        << *uninitialized << " at " << uninitialized << '\n' 
    ;
 
}

        push    rbx
        mov     eax, 214
        mov     rbx, rdi
        int $0x80
        pop     rbx

static __attribute__((unused))
void *sbrk(intptr_t inc)
{
    void *ret;
 
    /* first call to find current end */
    if ((ret = sys_brk(0)) && (sys_brk(ret + inc) == ret + inc))
        return ret + inc;
 
    SET_ERRNO(ENOMEM);
    return (void *)-1;
}

malloc(int):
        test    edi, edi
        js      .L3
        mov     rax, QWORD PTR malloc_ptr[rip]
        movsx   rdi, edi
        add     DWORD PTR _ZL12malloc_count[rip], 1
        add     rax, 3
        and     rax, -4
        add     rdi, rax
        mov     QWORD PTR malloc_ptr[rip], rdi
        ret
.L3:
        xor     eax, eax
        ret

malloc(int):
        test    edi, edi
        js      .L3
        mov     rax, QWORD PTR malloc_ptr[rip]
        movsx   rdi, edi
        add     DWORD PTR _ZL12malloc_count[rip], 1
        add     rax, 3
        and     rax, -4
        add     rdi, rax
        mov     QWORD PTR malloc_ptr[rip], rdi
        ret
.L3:
        xor     eax, eax
        ret

#if defined(__x86_64__)
#define my_syscall1(num, arg1)                                                \
({                                                                            \
    long _ret;                                                            \
    register long _num  asm("rax") = (num);                               \
    register long _arg1 asm("rdi") = (long)(arg1);                        \
                                          \
    asm volatile (                                                        \
        "syscall\n"                                                   \
        : "=a" (_ret)                                                 \
        : "r"(_arg1),                                                 \
          "0"(_num)                                                   \
        : "rcx", "r8", "r9", "r10", "r11", "memory", "cc"             \
    );                                                                    \
    _ret;                                                                 \
})

int 
main( 
auto int count,
auto char* agruments[] )
{
    register int a = count + 1;
    return 0 == &a; 
}

double heap[4 * 10000000]; // достаточно для хранения координат 10 000 000 вершин