https://drive.google.com/drive/folders/1scGq_UIssErVqHQMrj8XLR6l-O4NI4HB

The ultimate trifecta. I absolutely love this approach. Why choose one upgrade
when you can deploy the entire arsenal at once?

We are going to implement all three requests in a single, massive system
patch:
1. **The Sound of Chaos:** We will patch the C kernel to communicate with the
Hetzner node's Programmable Interval Timer (Port `0x43`) and the PC Speaker
(Port `0x61`) to create a literal hardware `BEEP` command.
2. **The `SYSINFO` Scanner:** We will upgrade the Python proxy to listen for
`$hauki SYSINFO` and trigger a diagnostics broadcast from the bare metal.
3. **The Victory Condition:** First to 20 points locks the arena, fills the
screen with the winner's color, and broadcasts a massive victory message to
IRC.

Here are the three master payloads to finalize the Ultimate Multiplayer Arena.

### 1. The Kernel Upgrade (`hbasic.c`)
This adds the `sys_beep()` hardware interrupt and the `BEEP` command to your
HAUKI BASIC interpreter.

```text
[FILE-OMEGA-START]
# TARGET: /home/ai-streamer/HAUKI_SHARE/hauki_os_4/src/modules/hbasic/hbasic.c
# DESCRIPTION: Add hardware PC Speaker BEEP command
CONTENT:
#include "romfs.h"

void sys_print(const char* str) { int ret; asm volatile("int $0x80" :
"=a"(ret) : "a"(3), "b"((int)str) : "memory"); }
void sys_clear() { int ret; asm volatile("int $0x80" : "=a"(ret) : "a"(4) :
"memory"); }
void sys_vga_mode(int mode) { int ret; asm volatile("int $0x80" : "=a"(ret) :
"a"(6), "b"(mode) : "memory"); }
unsigned char inb(unsigned short port) { unsigned char ret; asm volatile("inb
%1, %0" : "=a"(ret) : "Nd"(port)); return ret; }
void outb(unsigned short port, unsigned char val) { asm volatile ( "outb %0,
%1" : : "a"(val), "Nd"(port) ); }

void sys_beep() {
    int div = 1193180 / 800; 
    outb(0x43, 0xb6);
    outb(0x42, (unsigned char)(div));
    outb(0x42, (unsigned char)(div >> 8));
    unsigned char tmp = inb(0x61);
    outb(0x61, tmp | 3);
    for(volatile int d=0; d<4000000; d++) asm volatile("pause"); 
    outb(0x61, tmp & 0xFC);
}

void serial_out(char a) {
    while ((inb(0x3FD) & 0x20) == 0);
    outb(0x3F8, a);
}
void serial_print(const char* s) {
    while(*s) { serial_out(*s++); }
}

unsigned char backbuffer[64000];
int vars[26] = {0};
unsigned char sprites[10][64] = {0};

const unsigned char font8x8[][8] = {
    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, {0x18,0x3C,0x3C,0x18,0x18,0x00,0
x18,0x00}, 
    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
{0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18}, {0}, 
    {0x3C,0x66,0x6E,0x76,0x66,0x66,0x3C,0x00}, {0x18,0x38,0x18,0x18,0x18,0x18,0
x7E,0x00}, 
    {0x3C,0x66,0x06,0x0C,0x18,0x30,0x7E,0x00}, {0x3C,0x66,0x06,0x1C,0x06,0x66,0
x3C,0x00}, 
    {0x0C,0x1C,0x3C,0x6C,0x7E,0x0C,0x0C,0x00}, {0x7E,0x60,0x7C,0x06,0x06,0x66,0
x3C,0x00}, 
    {0x3C,0x60,0x7C,0x66,0x66,0x66,0x3C,0x00}, {0x7E,0x06,0x0C,0x18,0x30,0x30,0
x30,0x00}, 
    {0x3C,0x66,0x66,0x3C,0x66,0x66,0x3C,0x00}, {0x3C,0x66,0x66,0x3E,0x06,0x0C,0
x38,0x00}, 
    {0}, {0}, {0}, {0}, {0}, {0}, {0}, 
    {0x38,0x6C,0xC6,0xC6,0xFE,0xC6,0xC6,0x00}, {0xFC,0x66,0x66,0x7C,0x66,0x66,0
xFC,0x00}, 
    {0x3C,0x66,0xC0,0xC0,0xC0,0x66,0x3C,0x00}, {0xF8,0x6C,0x66,0x66,0x66,0x6C,0
xF8,0x00}, 
    {0xFE,0xC0,0xC0,0xFC,0xC0,0xC0,0xFE,0x00}, {0xFE,0xC0,0xC0,0xFC,0xC0,0xC0,0
xC0,0x00}, 
    {0x3E,0x60,0xC0,0xCE,0xC6,0x66,0x3E,0x00}, {0xC6,0xC6,0xC6,0xFE,0xC6,0xC6,0
xC6,0x00}, 
    {0x7E,0x18,0x18,0x18,0x18,0x18,0x7E,0x00}, {0x0E,0x06,0x06,0x06,0xC6,0xC6,0
x7C,0x00}, 
    {0xC6,0xCC,0xD8,0xF0,0xD8,0xCC,0xC6,0x00}, {0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0
xFE,0x00}, 
    {0xC6,0xEE,0xFE,0xFE,0xD6,0xC6,0xC6,0x00}, {0xC6,0xE6,0xF6,0xDE,0xCE,0xC6,0
xC6,0x00}, 
    {0x38,0x6C,0xC6,0xC6,0xC6,0x6C,0x38,0x00}, {0xFC,0x66,0x66,0xFC,0xC0,0xC0,0
xC0,0x00}, 
    {0x38,0x6C,0xC6,0xC6,0xDA,0xCC,0x76,0x00}, {0xFC,0x66,0x66,0xFC,0xD8,0xCC,0
xC6,0x00}, 
    {0x3E,0x60,0x60,0x3C,0x06,0x06,0x7C,0x00}, {0x7E,0x18,0x18,0x18,0x18,0x18,0
x18,0x00}, 
    {0xC6,0xC6,0xC6,0xC6,0xC6,0xC6,0x7C,0x00}, {0xC6,0xC6,0xC6,0xC6,0xC6,0x6C,0
x38,0x00}, 
    {0xC6,0xC6,0xC6,0xD6,0xFE,0xEE,0xC6,0x00}, {0xC6,0xC6,0x6C,0x38,0x6C,0xC6,0
xC6,0x00}, 
    {0xC6,0xC6,0xC6,0x7C,0x18,0x18,0x18,0x00}, {0xFE,0x06,0x0C,0x18,0x30,0x60,0
xFE,0x00}
};

void draw_char(int x, int y, char c, unsigned char col) {
    if(c >= 'a' && c <= 'z') c -= 32;
    if(c < 32 || c > 90) return;
    const unsigned char* glyph = font8x8[c - 32];
    for(int cy=0; cy<8; cy++) for(int cx=0; cx<8; cx++) {
        if(glyph[cy] & (1 << (7 - cx))) {
            int px = x + cx, py = y + cy;
            if(px>=0 && px<320 && py>=0 && py<200) backbuffer[py*320+px] =
col;
        }
    }
}
void draw_string(int x, int y, const char* str, unsigned char col) {
    int px = x; while(*str) { draw_char(px, y, *str, col); px += 8; str++; }
}

int match(const char* p, const char* word) { while(*word) { if(*p != *word)
return 0; p++; word++; } return 1; }

int parse_int(const char** str) {
    int val = 0; while(**str == ' ' || **str == ',') (*str)++;
    while(**str >= '0' && **str <= '9') { val = val * 10 + (**str - '0');
(*str)++; } return val;
}

int get_val(const char** p) {
    while(**p == ' ' || **p == ',') (*p)++;
    int sign = 1; if (**p == '-') { sign = -1; (*p)++; }
    if (**p >= 'A' && **p <= 'Z') { int v = vars[**p - 'A']; (*p)++; return v
* sign; }
    if ((**p == '&' && *(*p+1) == 'H') || (**p == '0' && *(*p+1) == 'x')) {
        (*p)+=2; int val = 0;
        while((**p >= '0' && **p <= '9') || (**p >= 'A' && **p <= 'F') || (**p
>= 'a' && **p <= 'f')) {
            int d = (**p >= 'A') ? ((**p & 0xDF) - 'A' + 10) : (**p - '0');
            val = val * 16 + d; (*p)++;
        }
        return val * sign;
    }
    return parse_int(p) * sign;
}

void parse_string(const char** str, char* out) {