Fix the errors:

```c++
// quic_server.cpp
#include <msquic.h>

#include <openssl/x509.h>
#include <openssl/pem.h>
#include <openssl/evp.h>
#include <openssl/x509v3.h>

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <map>
#include <memory>

using UniqueX509 = std::unique_ptr<X509, decltype(&X509_free)>;
using UniqueEVP = std::unique_ptr<EVP_PKEY, decltype(&EVP_PKEY_free)>;
using UniqueBIO = std::unique_ptr<BIO, decltype(&BIO_free_all)>;

// Globals & Constants
const QUIC_REGISTRATION_CONFIG RegConfig{ "game_sample", QUIC_EXECUTION_PROFILE_LOW_LATENCY };
const QUIC_BUFFER Alpn{ (uint32_t)strlen("gameplay"), (uint8_t*)"gameplay" };
const uint16_t Port = 7890;

const QUIC_API_TABLE* MsQuic = nullptr;
HQUIC Registration = nullptr;
HQUIC Configuration = nullptr;
HQUIC Listener = nullptr;

struct ClientContext {
    std::string Username;
};
std::map<HQUIC, ClientContext> ConnectedClients;

// Generate RSA key and self-signed cert with EVP_PKEY_keygen (OpenSSL 3.x friendly)
bool GenerateSelfSignedCert(std::string& certPem, std::string& keyPem) {
    bool ok = false;

    UniqueEVP pkey(nullptr, EVP_PKEY_free);
    {
        EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, nullptr);
        if (!ctx) return false;
        if (EVP_PKEY_keygen_init(ctx) <= 0) { EVP_PKEY_CTX_free(ctx); return false; }
        if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048) <= 0) { EVP_PKEY_CTX_free(ctx); return false; }
        EVP_PKEY* raw_pkey = nullptr;
        if (EVP_PKEY_keygen(ctx, &raw_pkey) <= 0) { EVP_PKEY_CTX_free(ctx); return false; }
        pkey.reset(raw_pkey);
        EVP_PKEY_CTX_free(ctx);
    }

    UniqueX509 x509(X509_new(), X509_free);
    if (!x509) return false;

    ASN1_INTEGER_set(X509_get_serialNumber(x509.get()), 1);
    X509_gmtime_adj(X509_get_notBefore(x509.get()), 0);
    X509_gmtime_adj(X509_get_notAfter(x509.get()), 315360000L); // 10 years
    X509_set_pubkey(x509.get(), pkey.get());

    X509_NAME* name = X509_get_subject_name(x509.get());
    X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC,
                               (unsigned char*)"localhost", -1, -1, 0);
    X509_set_issuer_name(x509.get(), name);

    if (X509_sign(x509.get(), pkey.get(), EVP_sha256()) == 0) return false;

    // PEM encode private key
    UniqueBIO bioKey(BIO_new(BIO_s_mem()), BIO_free_all);
    if (!bioKey) return false;
    if (!PEM_write_bio_PrivateKey(bioKey.get(), pkey.get(), nullptr, nullptr, 0, nullptr, nullptr))
        return false;

    // PEM encode cert
    UniqueBIO bioCert(BIO_new(BIO_s_mem()), BIO_free_all);
    if (!bioCert) return false;
    if (!PEM_write_bio_X509(bioCert.get(), x509.get())) return false;

    char* data = nullptr;
    long size = BIO_get_mem_data(bioKey.get(), &data);
    if (size > 0) keyPem.assign(data, size);

    size = BIO_get_mem_data(bioCert.get(), &data);
    if (size > 0) certPem.assign(data, size);

    return true;
}

// Forward declarations for callbacks
QUIC_STATUS QUIC_API ServerStreamCallback(HQUIC Stream, void* Context, QUIC_STREAM_EVENT* Event);
QUIC_STATUS QUIC_API ServerConnectionCallback(HQUIC Connection, void* Context, QUIC_CONNECTION_EVENT* Event);
QUIC_STATUS QUIC_API ServerListenerCallback(HQUIC Listener, void* Context, QUIC_LISTENER_EVENT* Event);

// Callback implementations

QUIC_STATUS QUIC_API ServerStreamCallback(HQUIC Stream, void* Context, QUIC_STREAM_EVENT* Event) {
    auto Connection = (HQUIC)Context;

    switch (Event->Type) {
    case QUIC_STREAM_EVENT_RECEIVE:
        if (Event->RECEIVE.BufferCount == 1) {
            auto& buf = Event->RECEIVE.Buffers[0];
            std::string username(reinterpret_cast<const char*>(buf.Buffer), buf.Length);
            auto it = ConnectedClients.find(Connection);
            if (it != ConnectedClients.end() && it->second.Username.empty()) {
                it->second.Username = username;
                printf("[server] Client %p username: %s\n", Connection, username.c_str());

                std::string welcome = "Welcome, " + username + "!\n";
                QUIC_BUFFER sendBuf{ (uint32_t)welcome.size(), (uint8_t*)welcome.data() };
                MsQuic->StreamSend(Stream, &sendBuf, 1, QUIC_SEND_FLAG_NONE, nullptr);
            }
        }
        break;

    case QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE:
        MsQuic->StreamClose(Stream);
        break;

    default:
        break;
    }
    return QUIC_STATUS_SUCCESS;
}

QUIC_STATUS QUIC_API ServerConnectionCallback(HQUIC Connection, void* /*Context*/, QUIC_CONNECTION_EVENT* Event) {
    switch (Event->Type) {
    case QUIC_CONNECTION_EVENT_CONNECTED:
        printf("[server] Connection connected %p\n", Connection);
        ConnectedClients[Connection] = {};
        break;

    case QUIC_CONNECTION_EVENT_SHUTDOWN_COMPLETE:
        printf("[server] Connection %p shutdown\n", Connection);
        ConnectedClients.erase(Connection);
        MsQuic->ConnectionClose(Connection);
        break;

    case QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED:
        MsQuic->SetCallbackHandler(Event->PEER_STREAM_STARTED.Stream, (void*)ServerStreamCallback, Connection);
        break;

    default:
        break;
    }
    return QUIC_STATUS_SUCCESS;
}

QUIC_STATUS QUIC_API ServerListenerCallback(HQUIC /*Listener*/, void* /*Context*/, QUIC_LISTENER_EVENT* Event) {
    if (Event->Type == QUIC_LISTENER_EVENT_NEW_CONNECTION) {
        MsQuic->SetCallbackHandler(Event->NEW_CONNECTION.Connection, (void*)ServerConnectionCallback, nullptr);
        return MsQuic->ConnectionSetConfiguration(Event->NEW_CONNECTION.Connection, Configuration);
    }
    return QUIC_STATUS_NOT_SUPPORTED;
}

int main() {
    int ret = -1;
    if (QUIC_FAILED(MsQuicOpen2(&MsQuic))) {
        fprintf(stderr, "MsQuicOpen2 failed\n");
        return ret;
    }

    if (QUIC_FAILED(MsQuic->RegistrationOpen(&RegConfig, &Registration))) {
        fprintf(stderr, "RegistrationOpen failed\n");
        goto cleanup_msquic;
    }

    std::string certPem, keyPem;
    if (!GenerateSelfSignedCert(certPem, keyPem)) {
        fprintf(stderr, "Failed to generate self-signed cert\n");
        goto cleanup_registration;
    }

    printf("Server Certificate PEM:\n%s\n", certPem.c_str());
    printf("Server Private Key PEM:\n%s\n", keyPem.c_str());
    printf("Copy above certificate PEM to client for trust.\n\n");

    // Write PEM files
    const char* certFileName = "tmp_server_cert.pem";
    const char* keyFileName = "tmp_server_key.pem";

    FILE* certFile = fopen(certFileName, "wb");
    if (!certFile) {
        fprintf(stderr, "Failed to open cert file for writing\n");
        goto cleanup_registration;
    }
    fwrite(certPem.data(), 1, certPem.size(), certFile);
    fclose(certFile);

    FILE* keyFile = fopen(keyFileName, "wb");
    if (!keyFile) {
        fprintf(stderr, "Failed to open key file for writing\n");
        remove(certFileName);
        goto cleanup_registration;
    }
    fwrite(keyPem.data(), 1, keyPem.size(), keyFile);
    fclose(keyFile);

    QUIC_CERTIFICATE_FILE certFileConfig{};
    certFileConfig.CertificateFile = (char*)certFileName;
    certFileConfig.PrivateKeyFile = (char*)keyFileName;

    QUIC_CREDENTIAL_CONFIG credConfig{};
    credConfig.Type = QUIC_CREDENTIAL_TYPE_CERTIFICATE_FILE;
    credConfig.CertificateFile = &certFileConfig;
    credConfig.Flags = QUIC_CREDENTIAL_FLAG_NONE;

    QUIC_SETTINGS settings{};
    settings.IdleTimeoutMs = 60000; // ms
    settings.IsSet.IdleTimeoutMs = TRUE;
    settings.PeerBidiStreamCount = 1;
    settings.IsSet.PeerBidiStreamCount = TRUE;

    if (QUIC_FAILED(MsQuic->ConfigurationOpen(Registration, &Alpn, 1, &settings, sizeof(settings), nullptr, &Configuration))) {
        fprintf(stderr, "ConfigurationOpen failed\n");
        goto cleanup_files;
    }

    if (QUIC_FAILED(MsQuic->ConfigurationLoadCredential(Configuration, &credConfig))) {
        fprintf(stderr, "ConfigurationLoadCredential failed\n");
        goto cleanup_config;
    }

    if (QUIC_FAILED(MsQuic->ListenerOpen(Registration, ServerListenerCallback, nullptr, &Listener))) {
        fprintf(stderr, "ListenerOpen failed\n");
        goto cleanup_config;
    }

    QUIC_ADDR addr{};
    QuicAddrSetFamily(&addr, QUIC_ADDRESS_FAMILY_UNSPEC);
    QuicAddrSetPort(&addr, Port);

    if (QUIC_FAILED(MsQuic->ListenerStart(Listener, &Alpn, 1, &addr))) {
        fprintf(stderr, "ListenerStart failed\n");
        goto cleanup_listener;
    }

    printf("Server listening on UDP port %u. Press Enter to exit...\n", Port);
    getchar(); // Wait for user input to exit

    ret = 0; // success

cleanup_listener:
    if (Listener) {
        MsQuic->ListenerClose(Listener);
        Listener = nullptr;
    }

cleanup_config:
    if (Configuration) {
        MsQuic->ConfigurationClose(Configuration);
        Configuration = nullptr;
    }

cleanup_files:
    remove(certFileName);
    remove(keyFileName);

cleanup_registration:
    if (Registration) {
        MsQuic->RegistrationClose(Registration);
        Registration = nullptr;
    }

cleanup_msquic:
    MsQuicClose(MsQuic);
    MsQuic = nullptr;

    return ret;
}
```

errors:

quic_server.cpp: In function ‘int main()’:
quic_server.cpp:248:1: error: jump to label ‘cleanup_config’
  248 | cleanup_config:
      | ^~~~~~~~~~~~~~
quic_server.cpp:225:14: note:   from here
  225 |         goto cleanup_config;
      |              ^~~~~~~~~~~~~~
quic_server.cpp:228:15: note:   crosses initialization of ‘QUIC_ADDR addr’
  228 |     QUIC_ADDR addr{};
      |               ^~~~
quic_server.cpp:248:1: error: jump to label ‘cleanup_config’
  248 | cleanup_config:
      | ^~~~~~~~~~~~~~
quic_server.cpp:220:14: note:   from here
  220 |         goto cleanup_config;
      |              ^~~~~~~~~~~~~~
quic_server.cpp:228:15: note:   crosses initialization of ‘QUIC_ADDR addr’
  228 |     QUIC_ADDR addr{};
      |               ^~~~
quic_server.cpp:254:1: error: jump to label ‘cleanup_files’
  254 | cleanup_files:
      | ^~~~~~~~~~~~~
quic_server.cpp:215:14: note:   from here
  215 |         goto cleanup_files;
      |              ^~~~~~~~~~~~~
quic_server.cpp:228:15: note:   crosses initialization of ‘QUIC_ADDR addr’
  228 |     QUIC_ADDR addr{};
      |               ^~~~
quic_server.cpp:258:1: error: jump to label ‘cleanup_registration’
  258 | cleanup_registration:
      | ^~~~~~~~~~~~~~~~~~~~
quic_server.cpp:193:14: note:   from here
  193 |         goto cleanup_registration;
      |              ^~~~~~~~~~~~~~~~~~~~
quic_server.cpp:228:15: note:   crosses initialization of ‘QUIC_ADDR addr’
  228 |     QUIC_ADDR addr{};
      |               ^~~~
quic_server.cpp:207:19: note:   crosses initialization of ‘QUIC_SETTINGS settings’
  207 |     QUIC_SETTINGS settings{};
      |                   ^~~~~~~~
quic_server.cpp:202:28: note:   crosses initialization of ‘QUIC_CREDENTIAL_CONFIG credConfig’
  202 |     QUIC_CREDENTIAL_CONFIG credConfig{};
      |                            ^~~~~~~~~~
quic_server.cpp:198:27: note:   crosses initialization of ‘QUIC_CERTIFICATE_FILE certFileConfig’
  198 |     QUIC_CERTIFICATE_FILE certFileConfig{};
      |                           ^~~~~~~~~~~~~~
quic_server.cpp:258:1: error: jump to label ‘cleanup_registration’
  258 | cleanup_registration:
      | ^~~~~~~~~~~~~~~~~~~~
quic_server.cpp:184:14: note:   from here
  184 |         goto cleanup_registration;
      |              ^~~~~~~~~~~~~~~~~~~~
quic_server.cpp:228:15: note:   crosses initialization of ‘QUIC_ADDR addr’
  228 |     QUIC_ADDR addr{};
      |               ^~~~
quic_server.cpp:207:19: note:   crosses initialization of ‘QUIC_SETTINGS settings’
  207 |     QUIC_SETTINGS settings{};
      |                   ^~~~~~~~
quic_server.cpp:202:28: note:   crosses initialization of ‘QUIC_CREDENTIAL_CONFIG credConfig’
  202 |     QUIC_CREDENTIAL_CONFIG credConfig{};
      |                            ^~~~~~~~~~
quic_server.cpp:198:27: note:   crosses initialization of ‘QUIC_CERTIFICATE_FILE certFileConfig’
  198 |     QUIC_CERTIFICATE_FILE certFileConfig{};
      |                           ^~~~~~~~~~~~~~
quic_server.cpp:189:11: note:   crosses initialization of ‘FILE* keyFile’
  189 |     FILE* keyFile = fopen(keyFileName, "wb");
      |           ^~~~~~~
quic_server.cpp:258:1: error: jump to label ‘cleanup_registration’
  258 | cleanup_registration:
      | ^~~~~~~~~~~~~~~~~~~~
quic_server.cpp:170:14: note:   from here
  170 |         goto cleanup_registration;
      |              ^~~~~~~~~~~~~~~~~~~~
quic_server.cpp:228:15: note:   crosses initialization of ‘QUIC_ADDR addr’
  228 |     QUIC_ADDR addr{};
      |               ^~~~
quic_server.cpp:207:19: note:   crosses initialization of ‘QUIC_SETTINGS settings’
  207 |     QUIC_SETTINGS settings{};
      |                   ^~~~~~~~
quic_server.cpp:202:28: note:   crosses initialization of ‘QUIC_CREDENTIAL_CONFIG credConfig’
  202 |     QUIC_CREDENTIAL_CONFIG credConfig{};
      |                            ^~~~~~~~~~
quic_server.cpp:198:27: note:   crosses initialization of ‘QUIC_CERTIFICATE_FILE certFileConfig’
  198 |     QUIC_CERTIFICATE_FILE certFileConfig{};
      |                           ^~~~~~~~~~~~~~
quic_server.cpp:189:11: note:   crosses initialization of ‘FILE* keyFile’
  189 |     FILE* keyFile = fopen(keyFileName, "wb");
      |           ^~~~~~~
quic_server.cpp:181:11: note:   crosses initialization of ‘FILE* certFile’
  181 |     FILE* certFile = fopen(certFileName, "wb");
      |           ^~~~~~~~
quic_server.cpp:179:17: note:   crosses initialization of ‘const char* keyFileName’
  179 |     const char* keyFileName = "tmp_server_key.pem";
      |                 ^~~~~~~~~~~
quic_server.cpp:178:17: note:   crosses initialization of ‘const char* certFileName’
  178 |     const char* certFileName = "tmp_server_cert.pem";
      |                 ^~~~~~~~~~~~
quic_server.cpp:264:1: error: jump to label ‘cleanup_msquic’
  264 | cleanup_msquic:
      | ^~~~~~~~~~~~~~
quic_server.cpp:164:14: note:   from here
  164 |         goto cleanup_msquic;
      |              ^~~~~~~~~~~~~~
quic_server.cpp:228:15: note:   crosses initialization of ‘QUIC_ADDR addr’
  228 |     QUIC_ADDR addr{};
      |               ^~~~
quic_server.cpp:207:19: note:   crosses initialization of ‘QUIC_SETTINGS settings’
  207 |     QUIC_SETTINGS settings{};
      |                   ^~~~~~~~
quic_server.cpp:202:28: note:   crosses initialization of ‘QUIC_CREDENTIAL_CONFIG credConfig’
  202 |     QUIC_CREDENTIAL_CONFIG credConfig{};
      |                            ^~~~~~~~~~
quic_server.cpp:198:27: note:   crosses initialization of ‘QUIC_CERTIFICATE_FILE certFileConfig’
  198 |     QUIC_CERTIFICATE_FILE certFileConfig{};
      |                           ^~~~~~~~~~~~~~
quic_server.cpp:189:11: note:   crosses initialization of ‘FILE* keyFile’
  189 |     FILE* keyFile = fopen(keyFileName, "wb");
      |           ^~~~~~~
quic_server.cpp:181:11: note:   crosses initialization of ‘FILE* certFile’
  181 |     FILE* certFile = fopen(certFileName, "wb");
      |           ^~~~~~~~
quic_server.cpp:179:17: note:   crosses initialization of ‘const char* keyFileName’
  179 |     const char* keyFileName = "tmp_server_key.pem";
      |                 ^~~~~~~~~~~
quic_server.cpp:178:17: note:   crosses initialization of ‘const char* certFileName’
  178 |     const char* certFileName = "tmp_server_cert.pem";
      |                 ^~~~~~~~~~~~
quic_server.cpp:167:26: note:   crosses initialization of ‘std::string keyPem’
  167 |     std::string certPem, keyPem;
      |                          ^~~~~~
quic_server.cpp:167:17: note:   crosses initialization of ‘std::string certPem’
  167 |     std::string certPem, keyPem;
      |                 ^~~~~~~