Нужно написать код, который бы выводил сердце

#include <iostream>
 
int main() 
{
    std::cout << "❤️";
}

#include <iostream>
 int main() 
{
   system("chcp 65001 > NUL");
   std::wcout<<L"❤️";
   std::wcin.get();
   return 0;
}

#include <SFML/Graphics.hpp>
 
int main()
{
    sf::RenderWindow window(sf::VideoMode(400, 400), "SFML Heart");
 
    // Создаем объект фигуры сердца
    sf::ConvexShape heart(6);
 
    heart.setPoint(0, sf::Vector2f(200, 100));
    heart.setPoint(1, sf::Vector2f(220, 120));
    heart.setPoint(2, sf::Vector2f(240, 100));
    heart.setPoint(3, sf::Vector2f(240, 140));
    heart.setPoint(4, sf::Vector2f(200, 180));
    heart.setPoint(5, sf::Vector2f(160, 140));
    heart.setFillColor(sf::Color::Red);
 
    // Основной цикл отображения окна
    while (window.isOpen())
    {
        // Обработка событий
        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                window.close();
        }
 
        // Очистка экрана
        window.clear(sf::Color::White);
 
        // Рисуем сердце
        window.draw(heart);
 
        // Отображаем окно
        window.display();
    }
 
    return 0;
}

#include <iostream>
 
int main()
{
    std::cout << "\n\n\t\t\t  ♥♥   ♥♥\n\t\t\t ♥  ♥♥  ♥\n\t\t\t♥    ♥   ♥\n\t\t\t♥        ♥\n\t\t\t ♥      ♥\n\t\t\t  ♥    ♥\n\t\t\t    ♥♥\n\n\n";
    return 0;
}

#include <iostream>
 
int main()
{
    std::cout <<R"(
   ♥♥   ♥♥
  ♥  ♥♥  ♥
 ♥    ♥   ♥
 ♥        ♥
  ♥      ♥
   ♥    ♥
     ♥♥)";
    return 0;
}

#include <iostream>
int main() 
{
    std::cout << "\n"
        "\n\t\t\t  **   **"
        "\n\t\t\t *  ***  *"
        "\n\t\t\t*    *   *"
        "\n\t\t\t*        *"
        "\n\t\t\t *      *"
        "\n\t\t\t  *    *"
        "\n\t\t\t    **\n";
    std::cin.get();
    return 0;
}

#define NOMINMAX
#include <Windows.h>
#include <cmath>
#include <vector>
#include <algorithm>
typedef  unsigned int uint32_t;
 
 
struct vec2
{
    float x, y;
    vec2(float a,float b):x(a),y(b){}
};
vec2 operator*(vec2 const &lh, float rh) 
{ 
    return vec2(lh.x * rh, lh.y * rh); 
}
vec2 operator-(vec2 const &lh, vec2 const &rh) 
{ 
    return vec2(lh.x - rh.x, lh.y - rh.y); 
}
struct vec3
{
    float x, y, z;
    vec3(float a,float b,float c):x(a),y(b),z(c){}
};
vec3 operator+(vec3 const &lh, vec3 const &rh) 
{ 
    return vec3(lh.x + rh.x, lh.y + rh.y, lh.z + rh.z); 
}
vec3 operator*(vec3 const &lh, vec3 const &rh) 
{ 
    return vec3(lh.x * rh.x, lh.y * rh.y, lh.z * rh.z); 
}
vec3 operator*(vec3 const &lh, float rh) 
{ 
    return vec3(lh.x * rh, lh.y * rh, lh.z * rh); 
}
float dot(vec3 const &lh, vec3 const &rh) 
{ 
    return lh.x * rh.x + lh.y * rh.y + lh.z * rh.z; 
}
vec3 normalize(vec3 const &v) 
{ 
    return v * (1.0f / std::sqrt(dot(v, v))); 
}
 
// http://mathworld.wolfram.com/HeartSurface.html
float f(vec3 p)
{
    vec3 pp = p * p;
    vec3 ppp = pp * p;
    float a = pp.x + 2.25f * pp.y + pp.z - 1.0f;
    return a * a * a - (pp.x + 0.1125f * pp.y) * ppp.z;
}
 
// Bisection solver for y
float h(float x, float z)
{
    float a = 0.0f, b = 0.75f, y = 0.5f;
    for (int i = 0; i < 10; i++)
    {
        if (f(vec3(x, y, z)) <= 0.0f)
            a = y;
        else
            b = y;
        y = (a + b) * 0.5f;
    }
    return y;
}
vec3 normal(vec2 p)
{
    vec3 v = vec3(p.x, h(p.x, p.y), p.y);
    vec3 vv = v * v;
    vec3 vvv = vv * v;
    float a = -1.0f + dot(vv, vec3(1.f, 2.25f, 1.f));
    a *= a;
 
    return normalize(vec3(
        -2.0f * v.x * vvv.z + 6.0f * v.x * a,
            -0.225f * v.y * vvv.z + 13.5f * v.y * a,
            v.z * (-3.0f * vv.x * v.z - 0.3375f * vv.y * v.z + 6.0f * a)));
}
 
vec3 shade(vec2 fragCoord, vec2 resolution)
{
    vec2 t = (fragCoord * 2.0f - resolution) * (1.f / std::min(resolution.y, resolution.x));
    vec3 p = vec3(t.x, t.y, 0.f);
 
    vec3 tp = p * vec3(2.0f, 2.0f, 0.0f);
 
    if (f(vec3(tp.x, tp.z, tp.y)) <= 0.0f)
    {
        vec3 n = normal(vec2(tp.x, tp.y));
        float diffuse = dot(n, normalize(vec3(-1.f, 1.f, 1.f))) * 0.5f + 0.5f;
        float specular = std::pow(std::max(dot(n, normalize(vec3(-1.f, 2.f, 1.f))), 0.0f), 64.f);
        float rim = 1.0f - dot(n, vec3(0.f, 1.f, 0.f));
        return vec3(1.f, 0.f, 0.f) * diffuse + vec3(0.8f, 0.8f, 0.8f) * specular + vec3(0.5f, 0.5f, 0.5f) * rim;
    }
    else
        return vec3(1.f, 0.8f, 0.7f - 0.07f * p.y) * (1.f - 0.15f * std::sqrt(dot(p, p)));
}
float clamp(float v,float lo,float hi)
{
    if(v<lo)return lo;
    if(v>hi)return hi;
    return v;
}
long lround(float f)
{
    if(f-(long)f<0.5)
        return (long)f;
    return (long)f+1;
}
uint32_t toBGRA(vec3 color)
{
    const uint32_t r = 0xff & lround(clamp(color.x, 0.0f, 1.f) * 255.f);
    const uint32_t g = 0xff & lround(clamp(color.y, 0.0f, 1.f) * 255.f);
    const uint32_t b = 0xff & lround(clamp(color.z, 0.0f, 1.f) * 255.f);
    return (0xFF000000) | (r << 16) | (g << 8) | (b);
}
 
int main()
{
    HWND win = ::GetConsoleWindow();
    WINDOWINFO wi={};
    ::GetWindowInfo(win, &wi);
    HDC dc = ::GetDC(win);
    int w = wi.rcClient.right - wi.rcClient.left;
    int h = wi.rcClient.bottom - wi.rcClient.top;
 
    std::vector<uint32_t> pixels(w * h);
    for (int y = 0; y < h; ++y)
        for (int x = 0; x < w; ++x)
            pixels[y * w + x] = toBGRA(shade(vec2(float(x), float(y)), vec2(float(w), float(h))));
 
    BITMAPINFO bmi={};
 
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth = w;
    bmi.bmiHeader.biHeight = h;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 32;
    bmi.bmiHeader.biCompression = BI_RGB;
 
    ::StretchDIBits(dc,
        0, 0, w, h,
        0, 0, w, h,
        (void*)&(*pixels.begin()), &bmi, DIB_RGB_COLORS, SRCCOPY);
    ::ReleaseDC(win, dc);
    getchar();
}