About a year, maybe two years ago I stupidly spill drink on keyboard, immediate RIP.

Got myself a new one right away, obviously. Didn't have much money at the time so I cheaped out on it, got a piece of trash that can't read more than two inputs at once. Like say I can't hold down shift, press W and then space to jump, shit like that. I developed a little muscle memory to get around it, just quickly switching between running and jumping. Dumbest shit ever, it kills your momentum.

Anyway I don't mind that but I've started noticing the caps are disintegrating. Particularly Meta, Shift, Arrows, they're just destroyed. The Enter keycap flat-out shattered. I can see which key I hit the most by how much the plastic has... well, melted and caved in. my touch is fire (baby) oh yeah.

So, go into normie internet to look for stuff to buy. Yay consumerism, everything sucks. Look at these pieces o fshit. And these fucking websites man. Who designed this your mother, don't answer, your mother would've done a WAY better job. Ugh. Fucking bullshit.

And why is everything "gamer" and has that horrible rainbow aRrGeebEe shit. Dafuq, boi. This is some of the most visually displeasing shit I've ever seen, and I am a shit poster by trade, I have witnessed some of the most cavernous depths of the internet's unholy butthole. I thought bleeding through the urethra was painful, but no, this is somehow worse. I am experiencing such profound disgust it has affected me physically. Also am I just a ranting geezer at 31, heh, well best to be a rapidly mentally aging son of a bitch than a fucking jerkwad with an atrocious taste that somehow gets picked up and circlejackaloped off by an entire fucking industry.

But enough about your terrorized rectum, I have money to spend. Is that mechanical shit worth it I wonder. Like those oh so ~ a e s t h e t i c ~ shitbags that take keys away from you and yet charge you more for it. Like I don't care about it being cute, will the keys witstand the ecstasy of my flaming fingers. I type a lot, and I mean a lot, man. Have you ever seen my repos, millions upon millions of pseudo pornographic keystrokes spent on shit that does nothing, I am unashamed to admit it, now where is my medal of sin bestowed on me by the finest of malignant sponsors.

Anyway, fuck this rant, I lost my train of thought midway through and it became an abomination that I am too stubborn to hit delete on.

Also I have no delete key pls halp.

me is make search:
c fun strsub name was?

aI oVeRQuEEfvIew:
tHeRE iZ nO fUnKCHon iN ceE foR gEtTen sUb sTrEnggGzEn

no, that is lie! you are liar!
me is thumb you down. bad gugul.
me is make search again now.
oh wait memory return.
strstr.
right.
that the name silly me.
i be alias fun to strsub because more mnemonic.

but why is gugul degenerating search don't know.
ruining experience not OK.

please someone tell mister pichai is make search bad thanks.
i want good search back, can switch to duck?
open duck.
oh noes.
duck is degenerate now.
has duck.ai on frontpage.

whyyyyyyyyyyy me is make tears now.
need good search not gorgabe.

rebuild preprocessor package applying preprocessor OK.

dependency cycle: the preprocessor depends on the lib it's trying to process oh noes.

OK fixed. how? code duplication (just a little).
checkmate, motherfucker.

up yours best practices i am max wright, maximum crackhead power.

now syntax check file once preprocessor is applied. normally need fork, but slows down build. can do with function?

yes but file has dependency cycle with itself because trying to load it's symbol table while loading it's symbol table so cannot compile. oops.

how about overwrite namespace with namespace cat ++unique_id (static uint64_t)? OK can do. not even store original name, just cat OUT_${uid} to it.

work like charm. now have syntax error messages, format all shit.
utilize power of crack /at\s (?<fname>.+) \s line \s (?<line>\d+) , \s near "/\e[32;1m$+{fname}\e[0m at \e[33;21m$+{line}\n\n\e[36;1m```/;

excellent, now subst closing quotes, easier said than done or maybe not really. just catch /\n"/```\e[0m\n/ OK for now.

errmes easy read and build complete in under a second now vs TWO MINUTES before; willy tanner strikes again.

I wins cookie now. brb need more magic.

There was this question I came up with that was very good at inducing hallucinations on what at the time I thought was a *lobotomized* LLM.

I can't recall the exact wording right now, but in essence you asked it to perform OpenGL batched draw calls in straight x86_64 assembly. It would begin writing seemingly correct code, quickly run out of registers, and then immediately start making up register names instead of moving data to memory.

You may say: big deal, it has nowhere to pull from to answer such an arcane fucking riddle, so of course it's going to bullshit you. That's not the point. The point is it cannot realize that it's running out of registers, and more importantly, that it makes up a multitude of register names which _will_ degrade the context due to the introduction of absolute fabrications, leading to the error propagating further even if you clearly point out the obvious mistake.

Basically, my thought process went as follows: if it breaks at something fundamental, then it __will__ most certainly break in every other situation, in either subtle or overt ways.

Which begged the question: is it a trait of _this_ model in particular, or is it applicable to LLMs in general?

I felt I was on to something, but I couldn't be sure because, again, I was under the impression that the model on which I tested this was too old and stupid so as to consider these results significant proof of anything; AI is certainly not my field, so I had to entertain the idea that I could be wrong, albeit I did so begrudgingly -- for obvious reasons, I want at least "plausible based on my observations" rather than just "I can feel it in my balls".

So, as time went on, I made similar tests on other models whenever I got a chance to do so, and full disclosure, I spent no money on this so you may utilize that fact in your doomed attempt to disprove me lmao. Anyway, it's been a long enough while, I think, and I have a feeling you folks can guess the final answer already:

(**SLIGHTLY OMINOUS DRUM ROLL**)

The "lobotomy" in question was merely a low cap on context tokens (~4000), which I never went over in the first place; newer/"more advanced" models don't fare any better, and I have been _very_ lenient in what I consider a passable answer.

So that's that, is what I'm starting to think: I was right all along, and went through the burdensome hurdle of sincerely questioning the immaculate intuition of my balls entirely for naught -- learn from this mistake and never question your own mystical seniority. Just kidding, but not really.

The problem with the force of belief is it can work both ways, by which I mean, belief that I could be wrong is the reason I bothered looking further into it, whereas belief to the contrary very much compels me to dismiss doubt entirely. I don't need that, I need certainty, dammit. And though I cannot in good faith say that I am _certain_, "sufficiently convinced" will have to do for the time being.

TL;DR I don't know but the more I see it just seems shittier.

me: just removing trash and bloat, no biggie.

walrus: nO RpERFACkTOWwwrRRinG noOOoOooOO UuHH!! YYYYOu IZ roEwFAuKToRyG!!!!!!!1!!one lOwW zElFf ztTeEMMmMme && sO ~~wEk~~!!

me: hehe rm -rf go brrrrrrrrrrrrrrrrrrr.

I may frame this.

OK, I think Ive figured out how I want to implement the core of my game.

Basic idea. Everything is made of sigils. What is a sigil? Lorewise, a representation of a concrete idea. Mechanically, it's a container for one or more ingame effects.

Again, anything you can think of, be it mundane or arcane, is a sigil. Every object attribute and method that causes a mutation of the game world state is composed of either a single or a sequence of sigils, known as a signa. You can do abstraction and have one thing encapsulate others, all that good stuff.

We go turnbased because tabletop rules. In your turn, you choose what to do with the sigils available to you. Common stuff like walk, talk, crouch, attack, et cetera are available to everyone.

You choose which effects to use, keeping in mind that order matters, and these effects either clash against or boost each other according to internal rules. Any relevant environmental modifiers around you or status effects apply here as well. Theyre also made of sigils, so theyre just implicitly components of the spell.

Finally, we get the result. An aura. It is simply the aggregate of all the sigils, containing the final transaction that will be applied to the game world, with dicerolls, if any are needed, already performed.

So here's the crucial bit. We record the aura for each turn, taken by either the player or the game itself, which includes the sequence of sigils used. Because each of these are words, or a series of words, it can be used narratively.

Let me give you an example. You are in a swamp, you use your turn to move around. This gives you an aura like so.

src: player, location: swamp, status: ok, walk.

We push that to a stack the game can see.

Now the game has to take its turn, and will look at the stack to get ideas. So lets say this swamp hindered your movement, gave you some trouble getting around. This is noteworthy enough as it affected something in the game world, and theres nothing else going on, so its made into a topic. The game will now pay attention to it and make it available for talking about.

topic: swamp-slow on player-party.

Everything is sigils, remember? Speaking is an effect, as is giving you something to talk about. Adding a topic results in an aura, push that to the stack.

Maybe then the game decides have the players companion make a comment on this topic. OK, just pair speak with other sigils to make an expression. The current topic is simply about a single negative effect, so one or two should be enough for a comment.

Factoring in the companions traits, also sigils, and the fact that for now this only a minor annoyance, we end up with an aura.

speak: topic -> complain about.

Do you see where this is going yet? The spellmaker gives us the means for text generation. The key here is instead of processing natural language like a bunch of dumbasses we just have an array of structures meant specifically for this purpose.

Anyway, the player now takes their turn. They can keep silent and continue moving, or say something as well. So let's say you pick the speak sigil too because why not, the current topic is also available to you, so you can reply. Depending on what the last message (aura) was, you get a range of options, and why not, let's factor in the player's chosen traits as well.

speak: shutdown -> complain about topic DOT change-topic -> mcguffin-quest.

We're on a mission to recover some plot stuff so shut up.

This results in further state changes, albeit behind the scenes. Our companion isn't happy, and we have a sequence of structures to prove it. Actions taken in relation to a topic can be associated with it if they're deemed significant, id est they caused a mutation of the game world's state.

speak: remind -> topic-name.

Thats right. Companion dude WILL remember that, you son of a bitch, and you bet your ass hes gonna bring it up if you keep acting like youre his boss or some shit. You dont even pay him!

You may say its such a small thing, but it all matters in a story. So we keep track of it, see what we can make this branch off into once a little more time has gone by.

What do you mean crazy, Im a fucking patrician of tenebrous arcana. You solve the problem by not solving the problem, obviously. Fuck natural language processing, all my homies use Litechnics to make narrative-driven programmable representations of the human condition.

Further rules include breaking gameplay down into scenes and acts as if it were theatre, because why not, and having baddies cooking shit up behind the scenes. Mechanism for that is the same, read the current stack and output structured wordsoup based on it.

We can even have a chorus narrating.
Or an audience reacting lmao.

OH GOD.
BUT I'M SO FRIGGIN SLOW OF A DEV.

WHAT IF I DON'T LIVE LONG ENOUGH TO IMPLEMENT THIS?
SHIT.

WORST SHOULD COME TO PASS,
PLEASE AVENGE MY DEATH.

PERLGUTS
PERLXS
XSUBPP

DEATH
DEATH
DEATH

util: YOU CANT PASS VERSION IN THAT FORMAT IT MUST BE A VERSION OBJECT FROM THE VERSION MODULE IN THE VERSION CINEMATIC UNIVERSE BLAHBLAHB LAHBLAH BLAHBLAH (...) CANT COMPILE THOUGH EVERYTHING ELSE IS CORRECT.

me: fuck you, it's just a string. i'll pass it however the fuck i want, using whichever format i feel like, and your standards will suck my dick day and night.

util: NOOOOO!!! I WAS PROGRAMMED TO THROW AND DIE AND BURN ON THIS VERY SPECIFIC AND INFINITELY STUPID CONDITION THERE IS NOTHING YOU CAN DO!!

me: well you're a build tool so i guess i could just replace you with inhouse, right? i mean https://github.com/Liebranca/... im just the kinda guy to do it.

util: WHAT?!! NO PLEASE I DIDN'T MEAN T- **FUCKING DIES**

me: get uninstalled bitch.

I used inline C in perl to write inline assembly.

I deserve death.

For devJs (I think?), who asked me what I was working on after I said uuuh me is hexdump diver, here is some logs so as to illustrate the boring stuff I'm doing lmao:

; just checking what I'm allocating c:
0000000000000000 : ALO 000000001B0C42B0

; ^taking that allocation and inspecting it
$0000 <: 000000001B0C42B0

00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................

00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................

; it's 128 bytes, so OK, good.
; then I say perform some writes
000000001B0C42B0 : WRT [ 0 .. 56] | 128 ( 56 * 1)
000000001B0C42E8 : WRT [ 56 .. 61] | 128 ( 5 * 1)

; ^look at the buf again to check that I wrote what I
; ^intended to write
$0000 <: 000000001B0C42B0

0000558D F7C480C0 : 00000000 00000000 | .....U..........
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 544F4F52 | ........ROOT....

00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................

; ... do some more writes, and so it keeps going
000000001B0C42ED : WRT [ 61 .. 117] | 128 ( 56 * 1)
000000001B0C4325 : WRT [ 117 .. 119] | 128 ( 2 * 1)

; ^inspect...
$0000 <: 000000001B0C42B0

0000558D F7C480C0 : 00000000 00000000 | .....U..........
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : FFFFC300 544F4F52 | ........ROOT....

FFFFC3FF FFFFFFFF : 000000FF FFFFFFFF | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00002400 00000000 : 00000000 00000000 | .....$..........

; and here it crashes because I somehow still wrote
; outside of bounds ;> FUUUUUUUUUUUUUUCKKKK
realloc(): invalid next size
Aborted (core dumped)

I'm actually pretty fucking pissed that what may possibly be my last comments on devotion rant where not delirious tangents. No fair.

Now, let's huddle together and blame someone for this mild inconvenience with no basis for the accusation whatsoever, brb I'ma go get the torches ready...

lets run test funny experiment with memories OK.

> Fatal glibc error: malloc.c:2601 (sysmalloc): assertion failed: (old_top == initial_top (av) && old_size == 0) || ((unsigned long) (old_size) >= MINSIZE && prev_inuse (old_top) && ((unsigned long) old_end & (pagesize - 1)) == 0)

well fuck.

echo "circle jerk" &> /dev/null

g++: TWENTY SCREENFULS WORTH OF ERRMES.

the mistake: `v=ptr` should be `v=*ptr`.

dude whenever someone says anything about idiomatic ceepluesplues I'ma just SLAP EM WITH A FISH~

Okay, summary of previous episodes:

1. Worked out a simple syntax to convert markdown into hashes/dictionaries, which is useful for say writing the data in a readable format and then generating a structured representation from it, like say JSON.

2. Added a preprocessor so I could declare and insert variables in the text, and soon enough realized that this was kinda useful for writing code, not just data. I went a little crazy on it and wound up assembling a simple app from this, just a bunch of stuff I wanted to share with friends, all packed into a single output html file so they could just run it from the browser with no setup.

3. I figured I might as well go all the way and turn this into a full-blown RPG for shits and giggles. First step was testing if I could do some simple sprites with SVG to see how far I could realistically get in the graphics department.

Now, the big problem with the last point is that using Inkscape to convert spritesheets into SVG was bit of a trouble, mostly because I am not very good at Inkscape. But I'm just doing very basic pixel art, so my thought process was maybe I can do this myself -- have a small tool handle the spritesheet to SVG conversion. And well... I did just that ;>

# pixel-to-svg:
- Input path-to-image, size.
- grep non-transparent pixels.
- Group pixels into 'islands' when they are horizontally or vertically adjacent.
- For each island, convert each pixel into *four* points because blocks:
· * (px*2+0, py*2+0), (px*2+1, py*2+0), (px*2+1, py*2+1), (px*2+0, py*2+1).
· * Each of the four generated coordinates gets saved to a hash unique to that island, where {coord: index}.

- Now walk that quad-ified output, and for each point, determine whether they are a corner. This is very wordy, but actually quite simple:
· * If a point immediately above (px, py-1) or below (px, py+1) this point doesn't exist in the coord hash, then you know it's either top or bottom side. You can determine whether they are right (px+1, py) or left (px-1, py) the same way.
· * A point is an outer corner if (top || bottom) && (left || right).
· * A point is an inner corner if ! ((top || bottom) && (left || right)) AND there is at least _one_ empty diagonal (TR, TL, BR, BL) adjacent to it, eg: (px+1, py+1) is not in the coord hash.
· * We take note of which direction (top, left, bottom, right) every outer or inner corner has, and every other point is discarded. Yes.

Finally, we connect the corners of each island to make a series of SVG paths:
- Get starting point, remember starting position. Keep the point in the coord hash, we want to check against it.
- Convert (px, py) back to non-quadriplied coords. Remember how I made four points from each pixel?
. * {px = px*0.5 + (px & 1)*0.5} will transform the coords from quadriple back to actual pixel space.
· * We do this for all coordinates we emit to the SVG path.

- We're on the first point of a shape, so emit "M${px} ${py}" or "m${dx} ${dy}", depending on whether absolute or relative positioning would take up less characters.
· * Delta (dx, dy) is just (last_position - point).

- We walk from the starting point towards the next:
· * Each corner has only two possible directions because corners.
· * We always begin with clockwise direction, and invert it if it would make us go backwards.
· * Iter in given direction until you find next corner.
· * Get new point, delete it from the coord hash, then get delta (last_position - new_point).
· * Emit "v${dy}" OR "h${dx}", depending on which direction we moved in.
· * Repeat until we arrive back at the start, at which point you just emit 'Z' to close the shape.
· * If there are still points in the coord hash, then just get the first one and keep going in the __inverse__ direction, else stop.

I'm simplifying here and there for the sake of """brevity""", but hopefully you get the picture: this fills out the `d` (for 'definition') of a <path/>. Been testing this a bit, likely I've missed certain edge cases but it seems to be working alright for the spritesheets I had, so me is happiee.

Elephant: this only works with bitmaps -- my entire idea was just adding cute little icons and calling it a day, but now... well, now I'm actually invested. I can _probably_ support full color, I'm just not sure what would be a somewhat efficient way to go about it... but it *is* possible.

Anyway, here's first output for retoori maybe uuuh mystery svg tag what could it be?? <svg viewBox="0 0 8 8" height="16" width="16"><path d="M0 2h1v-1h2v1h2v-1h2v1h1v3h-1v1h-1v1h-1v1h-2v-1h-1v-1h-1v-1h-1Z" fill="#B01030" stroke="#101010" stroke-width="0.2" paint-order="stroke"/></svg>

OK, I could maybe write a quick app in C++ and cross compile it so I can send it to my friends who use windows, what is wrong with you I am ashamed for us all.

But why do that? Let's just go the EXTREME route and do things in a very inappropriate way that is natively """portable""" so we can say that (((It Just Works™))).

So if you haven't guessed already, it's 100% js rawdogging and I'm doing the graphics in SVGOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH NOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO uoykuf OoOOOOOOOOOOOOOOOOOOOOOOoOOOOOOOOOOOOOOOOOOOOO it's not so bad but here's things I've learned:

If you're using inkscape to convert your lazy 8x8 pixels per frame spritesheet.png into an svg file, and don't know how to use inkscape, you have to stack each frame on top of one another. Yes.

Erase the layers, erase everything that isn't the paths you want. Also erase invisible paths generated by the pixelart mode of the trace bitmap thingy, sometimes these ghosts exist for mysterious reasons.

Then, neatly stack everything into one square big enough to hold all the frames, select all the frames, resize to selection. OK, now double check that the names of your layers werent changed to generic path94958509 out of the fucking blue AGAIN, all good.

Also double check that inkscape hasn't changed the name and extension of your output file AGAIN then make sure inkscape hasn't changed the dimensions of your export AGAIN and then AGAIN and AGAIN...

OK, so you've exported your svg, now we start doing even more stupid and questionable things. We go into the file and delete the header, specially the comment at the top that clearly states this file was made with inkscape, because my experience was so DELIGHTFUL that I very much require some abstract form of petty vengeance. Also a cigarette.

Hold on. Patiently erase useless tags such as defs and g and shit, all you want is the svg and paths. Then, painstakingly convert each <path id=$ .../> into <symbol id=$> <path .../>.

Why didn't I write a perl script for this part? Actually that's a good idea, goes on the todolist, I didn't write a todolist app though, because I have a textfile. I mean, just what kind of negative IQ troglodyte would do something like that? ;>;>;>;>;>;>;>

Anyway, now utilize your black-magic-infused devilspeak q$p e r l$ script to fasten together an entire webapp into a single html file, all done with duct tape and clown jizz of course, see previous rant for VERY technical details. Also I jjust time traveled and wrote the previous paragraph while writing this one everything is out of order oh noes.

No matter it works now me is happiee.

I got heart icon for health bar but no health bar implemented not aproblem.

Uh also outlines. Here, let's keep it topical, this is rom.rol:

```rol
# vars:
$:%peso;>
let sprite,"$.elems.srpite";
$:/peso;>
# css:
$:%asis;>
path {
· stroke: $080808;
· stroke-width: 0.1;
· stroke-linejoin: round;
· paint-order: stroke;
}
$:/asis;>
# html:
$:%asis;>
<svg width="2.1166811mm" height="2.1166601mm" viewBox="0 0 2.1166811 2.1166601" xmlns="http://www.w3.org/2000/svg">
<symbol id="{$$.%sprite}_hp_0">
<path d="M 0.264594,0.26458 V 0.52916 H 1.1e-5 V 0.79375 1.05833 1.32291 H 0.264594 V 1.5875 H 0.529177 V 1.85208 H 0.793761 V 2.11666 H 1.058344 1.322927 V 1.85208 H 1.587511 V 1.5875 H 1.852094 V 1.32291 H 2.116677 V 1.05833 0.79375 0.52916 H 1.852094 V 0.26458 H 1.587511 1.322927 V 0.52916 H 1.058344 0.793761 V 0.26458 H 0.529177 Z"/>
</symbol>
<!--NOW DO THE OTHER NINE FRAMES-->
</svg>
$:/asis;>
```

so now I can say (in base.rol):
```rol
$:%peso;>
lib "[based]";
rol "rom.rol";
let hud,"$.elems.hdu";
$:/peso;>
$:%asis;>
<svg viewBox="0 0 23.283329 2.1166601" width="16%" height="16%" fill="#880808">
<use id="{$$.%hud}_hp" href="#{$rom.%sprite}_hp_0"/>
</svg>
<script>
document.getElementById("{$$.%hud}_hp").setAttribute('href',"#{$rom.%sprite}_hp_" + n).
</script>
$:/asis;>
```

Where `n` is just some frame counter this is duct tape now request animation frames REQUEST THEM YOU MUST.

Anyway this is immensely stupid but it made me giggle so I share.
AAA RPG with full svg graphics when?

OK here's lang, very easy.

set lines, (split "\n", orc fname). ; ORC -- open, write, close
map lines, strip.
grep lines, filter blanks.

map lines, # lineproc:

- on line match, qr~^# \s* (?<name> [\a]+) \((?<type> [\a+])\) \s*:\s*~x.
· · * have type or default type.
· · * set dst, name or new type name.

- on line match, qr~^\- (?<name> .*)~x.
· · * dst->cur eq dst->[name] eq new list name.

- on line match qr~^\* (?<item> .*)~x.
· · * push dst->cur, item.

- else
· · * cat dst->cur, line or throw fuk.

I'm skipping over a couple edge cases (no dst/cur, I be throw fuk for brevity) but you get the gist of it maybe.

Anyway what's this for? Lists, like so:

```rol
# dst (type):
- attr:
· · * hi im item one in list
· · · still item one lmao.
· · * hi im item two in list.
```

That gives `dst { attr: [item_1, item_2] }`. There's another bit I'm omitting to make this recursive so as to allow for nested dicts, but nevermind that it's a tree you get it right.

So what it's lame. Yes. Let's smoke some crack now I can add preprocessor in subclass:
```
# dst (cracktype):
$:%fn args;>
(text)
$:/fn;>
```

That will call `fn text,args` to process text __before__ lineproc, `fn` is just callback from callback table in Nebraska maybe.

$:peso;> syntax is just so text can contain funstuff OK.
I like <fn args /> better, and $:this;> is just stuff no one ever writes so it's safe to use.

Want to reference object in text too, what? `{$obj [fn args]}` anywhere in text to make call, now can do database lookup so naming be important. Have import mechanism to fetch collections, can't bother showing.

Anyway what's the point I dunno, just copying and pasting from local library to pack entire app in single html file. Why? Can't remember; doesn't matter.

Also can convert to json but I prefer my own version of it.
Called jargon.
Same thing but no quotes just because so `obj {attr:[(value), (value)]}`.
Now eat baguettes.

Have a nice wallop.

Journalists reading tweets sent by grand ayatollah Khamenei live on argentinian TV is kinda surreal but I guess this is where we're at now.

Me, reading random wikipedia:

A boutonnière (French: [bu.tɔ.njɛʁ]) or butthole (British English) is a floral decoration, typically a single flower or bud, worn on the lapel of a tuxedo or suit jacket.

Wait, that can't be right

butthole.
buttonhole.

OOOOOH

Going through my lore notes. And I'm playing a game with myself, so to speak: it's called "is this metal enough?", but with a side of quasi-metaphysical arcane technobabble plus mass wallmelting and nightmarishly psychedelic confusion.

For example... why are shadow gates a thing? Well, because of the undoing of time caused a multiplicity of parallel cycles that will, inevitably, slowly collapse upon themselves through a sequence of irreducible asynchronicities. But of course!

Now, as for the metal part, that's the undoing of time. You see, the Somberlain attempted to cast the most sinful signa in order to restore the desolate mortal realm as it stood on the brink of a world-ending cataclysm, this was after a decade of brutal, reckless litechnical abuse during the civil war fought amongst the first undecimvirate...

Now, he intended to roll back time itself as a way to avoid the cataclysm and restore life to the mortal realm, but the cost was immense: time was not rolled back, but rather __forcefully__ torn apart; it was effectively shredded, shattered, and undone.

Countless lives were lost as nearly six hundred years of Being were __erased__ in an instant, the most heinous large-scale blood sacrifice in history, spanning the entirety of the lower fragment of reality. I mean is this too dark, I'm not sure. How about I clarify: he didn't just snuff out their lives, no, they CEASED TO EXIST. THEY NEVER EXISTED. GONE. UNBECOMED INTO A TRUE IMMEMORIAL. OVER FIVE CENTURIES OF EVERY CONSCIOUS MOMENT ON EARTH DEVOURED TO FUEL HIS DARK MAGIC.

That's gotta have consequences, right? Well, obviously you'll get temporal distortions after that shit, I mean duh...

But wait, I'm lost, you say the undecimvirate deified themselves but were cast down after the whole superman spinning the earth backwards thing went full bathory and erased entire centuries from the fabric of the cosmos, so they were turned into the eleven thrones to guard over the eleven circles of the night eternal... but how is that linked to natural occurrences of teleportation?

First off, because *natural* teleportation is distinct from *artificial* teleportation. Failed experiments with (and miscasts of) mass transference of living matter are one of the leading causes of death among litarchs. It is not an instant transmission, just very, very quick, moreso than a mortal mind can process, that's why the "dilate" and "delay" sigils are added, so as to make the journey seem slowed down to the perceptions of whomever is teletransported, this is meant to ensure their brains don't __melt__ from the experience.

Similar reason as to why you have to give the _approximate_ total weight to carry when inscribing the ritual circle, you *do* know that it is __highly__ recommended to use accurate weighing scales to approximate this quantity, as under or overestimating it can lead to _FATAL_ consequences... do you not?

No, *natural* occurrences of teleportation do not have these constraints for two reasons: one, because both ends of the gateway are _fixed_ in both time and space due to the logic-defying occurrence of a future event being undeniably the cause of the past it revisited. Put on this toga. They are inextricably linked through the metaphorical and *literal* corpse of infinite collapsed timelines, which generates a conduit through the first circle of the night eternal, which *is* the domain of both forgetfulness and horror immemorial.

Second, the final layer on our stratified reality, that is, the final circle before the INVIOLABLE divine veil, wraps around the night eternal, which is why we call it "the shell". Or "Crisalida" if you dig Luis Alberto. It is a realm entirely outside of time, which is why the patriarchs can grant immortality, you see. By proximity to this sacred shell of existence, the timeline-corpse-conduit that links both ends of a shadow gate is, for all intents and purposes, approaching total chronostasis, therefore making it so bypassing physical space in a few seconds doesn't give you permanent loss of the sense of self as your brain turns into liquified jelly.

I don't remember what I was getting at and I don't care.

Oh look at it stupid technomusings.

Context:
- You have a sequence of N-byte-wide values.
- Each value is unique.
- You XOR them all together into an N-byte-wide key.
- Just dump the key into a list somewhere.

Problem:
- A new value sequence is input.
- Same rules: all values are unique and fixed-size.
- You XOR them all together into a key.
- You walk the list of keys and check them for equality against the new one.

The same sequence of values, regardless of order, would ((supposedly)) always give you the same key. I used this years ago, for a renderer that used indexed colors, to see if I had to make a new palette or not when saving/loading textures: the image format had the key on the header.

It worked, but I was using a __very__ limited value range, cursed 8-bit YUV lossy fuckery; never bothered investigating the idea any further.

So, question:
- Is there any specific situation in which you get a false positive?
- Is there any specific situation in which you get a false negative?

My brain wants to say 'yes' to both because I'm privy to the mystical truth that my methods invariably fall on the idiot side of the spectrum. But my lazy testing keeps saying 'no, you dumbass'.

So who's wrong?
brb gon hit that crack~

Something like 50 of my sweet, sweet plusplus just went poof, gone. Vanished, gone with the wind.

Could be a bunch of salty downvotes, no doubt a limpdick way to try and protest my immaculate logic? That is indeed a possibility. But the most likely explanation is someone nuked himself.

And you know what? Shit, man.
This is giving me flashbacks to when rutee left devRant and I hate it.

btw rutee, Mr Johnny Sins, your location literally inside me: in case you ever read this, I just want to say, you is the kewlest; no contest. Everyone else get fucked. I'm sorry, but you're not rutee. Nothing compares2u or some forbidden bromance shit sang by a bald woman, all night up the ass.

Anyway, where was I?
Ah, yeah. People-check.

So who deleted himself? I'm not seeing anyone missing. The whole gang is here. I think. I mean even ostream's shadowclones are still around.

Hmm. Maybe I did get downvoted?
Or maybe it was just a bunch of rants getting deleted, rather than a full-on nuke?

Huh. Indubitably, this is a case for Willy Tanner.
*REACHES FOR THE CRACKPIPE.*

fknshit. Am I stressing about linting and formatting moreso than what the code itself does or is it just another hallucination?

I call it correctness paranoia. Bitch does it even compile. Yes, perhaps, but I absently-minded added a single newline somewhere, and that's no good.

So re-read the diff again: oh.

const auto&
should be
const auto
probably.
F is not returning a ref...
Should it return a ref?

Fuck, I'm declaring this nonref, should I
T N(V)
or
T N = V

Plain old doesn't fucking matter most of the time, but what if I missed a detail somewhere and so it *does* matter here?

REREAD. AGAIN.
SLOWLY.
DYING.
DYING.
DYING.

@retoor I did it I FUCKING DID IT. I CRACKED THE COWDZ.

HAVEN'T SLEPT IN ALMOST THREE DAYS.
BUT I FED THIS TO A LOBOTOMIZED BOTII.
IT WAS ABLE TO RUN MY RULESET.
WELL, A VERY LIMITED VERSION.
BUT STILL.

PRO VIBES-ORIENTED PROGRAMMING.
IN MARKDOWN.
PSEUDOMARKDOWN.
what?
WHAT??!!!!

OH YEAH.
BEHOOOOOLLLD THE POWER OF CRACK:

```
# Definition of Basic Terms:

- Actor;
· * "An Actor is a character or entity actively or passively participating in the game";

- Action:
· * "An Action is whatever an Actor does during their turn";
· * **IMPORTANT: "In addition to taking an Action during their own turn, an Actor can opt to prepare a Re-Action to activate during another Actor's turn, *if* they have enough SP/MP to do so"**;

- Signa:
· * "A Signa is an in-game effect that describes an Actor's Actions and Re-Actions";
· * "In-game effects can only alter values within the Actor->Status dict";
· * Signa->Caster = the Actor that activated the Signa;
· * Signa->Target = the Actor that is affected by the Signa;
· * **IMPORTANT: "A Signa can be cast 'OnSelf', that is, the Caster can choose to cause the effect on themselves"**;

---
# Actor Attributes:

- Actor->ReadOnly:
· * **IMPORTANT: "ReadOnly attributes represent an Actor's natural advantages and cannot be changed through in-game effects"**;
· * **IMPORTANT: "The purpose of these immutable attributes is determining the base values for game formulas"**;
· * "Actor->ReadOnly is a (key=>value) dict that stores the Actor's innate and immutable attributes";
· * **IMPORTANT: "These bonuses are fixed and cannot be altered by in-game effects"**;
· * "Each key corresponds to a specific game formula";
· * "Each value is a constant signed integer that represents a modifier for the associated formula";

- Actor->Grit:
· * Actor->ReadOnly->{"HP->Max"} = 8+(Actor->Grit*2);
· * "Actor->HP->Regen is not affected by Grit";
· * Actor->ReadOnly->{"Strength"} = Actor->Grit*1;
· * Actor->ReadOnly->{"Resist"} = Actor->Grit*1;

- Actor->Wit:
· * Actor->ReadOnly->{"MP->Max"} = 4+(Actor->Wit*2);
· * "Actor->MP->Regen is not affected by Wit";
· * Actor->ReadOnly->{"Intelligence"} = Actor->Wit*1;
· * Actor->ReadOnly->{"Dexterity"} = Actor->Wit*1;

- Actor->Charm:
· * Actor->ReadOnly->{"SP->Max"} = 1+(Actor->Charm*1);
· * Actor->ReadOnly->{"Perception"} = Actor->Charm*2;
· * Actor->ReadOnly->{"Charisma"} = Actor->Charm*2;

- Actor->Spirit:
· * Actor->ReadOnly->{"Arcana"} = Actor->Spirit*2;

- Actor->Faith:
· * Actor->ReadOnly->{"Defend"} = Actor->Faith*1;
· * Actor->ReadOnly->{"Heal"} = Actor->Faith*1;
· * Actor->ReadOnly->{"Bless"} = Actor->Faith*1;

- Actor->Hatred:
· * Actor->ReadOnly->{"Damage"} = Actor->Hatred*1;
· * Actor->ReadOnly->{"Curse"} = Actor->Hatred*1;

---
# Diceroll Definition:

- rand:
· * "A pseudo-random number between 0 and 0.99";

- roll->dX:
· * roll->dX = truncate (rand*X);

---
# Basic Formulas:

- Actor->Status:
· * "Actor->Status is a (key=>value) dict that stores the Actor's current status effects";
· * "These bonuses are temporary and can be altered by in-game effects";
· * "Each key corresponds to a specific game formula";
· * "Each value is a signed integer that represents a modifier for the associated formula";

- Actor->Damage:
· * let base = roll->d4;
· * let X = Actor->ReadOnly->{"Damage"};
· * let Y = Actor->Status->{"Damage"};
· * Actor->Damage = base+(X+Y);
· * "Result can be negative if (X+Y) is less than -base";

---
# Regeneration Rates:

- Actor->HP->Regen:
· * const base = 0;
· * let X = Actor->Status->{"HP->Regen"};
· * Actor->HP->Regen = base+X;
· * "Result can be negative if X is less than 0";

- Actor->MP->Regen:
· * const base = 1;
· * let X = Actor->Status->{"MP->Regen"};
· * Actor->MP->Regen = base+X;
· * "Result can be negative if X is less than -1";

- Actor->SP->Regen:
· * let base = Actor->Status->{"SP->Max"};
· * let X = Actor->Status->{"SP->Regen"};
· * Actor->SP->Regen = base+X;
· * "Result can be negative if X is less than -base";

---
# Default Signas:

- Movement (Signa):
· * Movement->Cost->SP = 1;
· * Movement->Cost->MP = 0;
· * Movement->Duration = 1 turn;
· * Movement->AreaOfEffect = 4 tiles;
· * "Allows the Caster to move the target up to 4 tiles distance";
· * **IMPORTANT: "This Signa does not allow the Caster to avoid obstacles"**;

- Attack (Signa):
· * Attack->Cost->SP = 1;
· * Attack->Cost->MP = 0;
· * Attack->Duration = 1 turn;
· * Attack->AreaOfEffect = 1 tile;
· * let dst = Attack->Target;
· * let src = Attack->Caster;
· * dst->HP->Current -= src->Damage;
· * **IMPORTANT: "This Signa never misses"**;
```

They once shared a romantic evening on the waterfront, discussing their preferences in Middle Eastern cuisine and enjoying the serene atmosphere.

LINEBREAK

This event occurred after an ((__orgy__)) at the Tower of Dawn, where the extravagance of their many geminous epigrams culminated in the temporary abolition of common etiquette due to serendipitous fuckenstance.

Consider,

```
namespace A;

macro m00 a,b;
··display a,b;
end macro;

macro m01 a;
··m00 a,$0A;
end macro;

m01 $24;
end namespace;
```
OUT: $0A24 ("$\n").

Ah, but you just HAD to fuck me in the ass, didncha fasm2? Initializing anal bleeding:

```
namespace B;
A.m01 $24;
end namespace;
```
OUT: illegal instruction 'm00'.

Explanation: macros carry no context, and so 'm00' is unreachable from 'B' namespace.

Could I maybe write a code-capture macro to generate a wrapper that resets the namespace? Yes, and in fact, I did; brilliant exercise in mystical mindfuckery.

But why try so hard? Just pass the fucking ref, like a MAN.
EXPLICIT CTX, BITCH.

```
define @CAS $non; current addressing space
define %ICE @CAS;

macro self:PA&; recursive macro, uuuh spooky-spooky
··match ice , %ICE;

····; self->proc(args)
····match =-=> proc (args) , PA;
······path.proc ice,args; pass ref and args

····; ^self->proc()
····else match =-=> proc () , PA;
······path.proc ice; pass ref only

····; ^sneaky sneaky. set current context when self ctx;
····else match cas , @CAS;
······%ICE equ cas.PA;

····end match;

··end match;
end macro;
```

ALL TOGETHER NOW
```
namespace A;

macro m00 ice,a,b;
··display a,b;
end macro;

macro m01 ice,a;
··self->m00(a,$0A); could also be 'ice.m00 ice,a,$0A' lmao
end macro;

end namespace;

namespace B;

self A; set ice
self->m01($24);
restore %ICE; back to previous

end namespace;
```

OUT: $0A24 ("$\n").

A-há, now **I** got you from behind motherfucker!

Final note: this is 100% perl DNA seeping through the cracks of my sanity and into a fresh fasm2 framework. Why? Dingle-dongle-jungle-berries, that's why. Also crack.

Have a nice wallop.

Turned 31 three days ago.

My **dad** was convinced that I was turning 30 instead lmao.

I had to do the math for him, he was questioning the fabric of reality for a second. Like baba 2025 sub 1994 eq 31, ok.

so anyway age--;

So, I have a nested ternary, right, and that's not very readable:

(x <= y ? z : (x <= z ? y : x));

The linter points this out and I'm like yeah, valid point. So I inline-F[*0] it:

if (x <= y)
········return z;
else if (x <= z)
········return y;
else
········return x;

Clearer? Kinda. Oh, but the linter doesn't like this either, and to be fair, valid point once again; an else-after-return *can* be quite confusing if you have it in the __middle__ of the F body, catches you by suprise.

However, I'd like to take a brief moment to waggle your nutsack, if you please. Because this is C++ and I'm picking a reference from a list of values, so I can't simply assout[*1] within the switch.

So I'm at the crossroads of life once again, losing man's toughest struggle as I sit on a metaphorical cigar, squirming while I unclench my asshole slowly for strictly defecatory purposes. Allow me to illustrate:

- If I ignore the linter, and leave the rest of the code unchanged, the checks are going to fail and the bot is going to taint my pristine PR with automated comments.
- But if I take the linter's advice, I have to do a slight rewrite of the damn thing plus every F that calls it, which means touching shit that has nothing to do with this issue.

So what's it gonna be? Flushing or shoving my own excrement? Oh, the thrills of it being (literally) SOLID, ie not the acronym, but may the Almighty punish Uncle Bob regardless.

NOTES:
[*0]: It means 'function,' what else?
[*1]: ASS-ign OUT-put, where 'out' is just some var. You modify the var within the F body and return the final value.

JUST IN: The unexpected sequel to my previous rant that NOBODY asked for!

I'll give it to you in dialogue form as it's more dramatic and *juicy* that way...

(Context: wizard used the warrior's blood, who descends from an ancient lineage of powerful sorcerors, to cast a high-level spell which allowed the party to teleport to safety when they were trapped and about to die. The warrior is worried about his crazy use of black magic, so she confronts him about it.)

"Alright, old man," she says, her tone serious, yet tinged with concern. "I couldn't help but notice the... let's call it 'unorthodox' spellcasting earlier. What was that about?"

"Well, you wanted me to draw the circle using golden dust and a lamb for the sacrifice?" Uzair raises an eyebrow, his tone riddled with sarcasm. "Because spells of that level of complexity require both things, you know? A circle and an offering." He explains calmly, then shakes his head. "But turns out, the blood of an Ashaffi accounts for both things if you draw the sigils with it. Hey, don't blame me, your own ancestors invented it!"

"Very funny, Uzair." Hashade crosses her arms, her expression unamused. "But seriously, that shit was utterly deranged. I can't have you going all 'Black Scorpion' on our ass, what with the demented use of blood magic, needlessly setting entire buildings ablaze and that mother fucking all-incinerating black hellfire inferno." Her voice is stern, but her eyes show genuine care. "You're... __BREAKING BAD__, old man! You have to chill."

"Oh, so is my wizardry getting on your neves now, is it?" He recoils back slightly in suprise, feeling offended. "We just spanked the Sanie's Guild buttcheeks until they were red and swollen, then proceeded to __FUCK__ them in the ASS with a *DIAMOND* fucking COCK. And you're complaining?"

Hashade's eye's reveal her agitation. "I'm not complaining, I'm concerned! We're not just fighting for ourselves, we're fighting for everyone else too! And if you start playing fast and loose with that kind of power, we're gonna have more than just *one* black smoldering crater to deal with." Her voice is firm, but it's clear she's trying to keep the situation from escalating. "Look, I know you're powerful, but that's not an excuse to go full-on mad scientist on us. We gotta keep our shit tight, yeah?"

"Concerned?!" He tilts his head to the side. "What, you think I'm becoming evil? Come on, spit it out!"

"Evil? No, I don't..." Hashade sighs, running a hand through her silver hair. "Oh no, you know what, yeah. I do. I think you're slowly turning evil." Her expression hardens. "You swapped your book of supplications for a grimoire detailing the most horrible shit in excruciating detail! You shouted out 'G-d is great' while witnessing a disastrous explosion that left everyone else traumatized! You joked around before and after cutting two guards in half, for fuck's sake!" She lowers her head and pinches her nose bridge. "I don't know, I'll admit that, I just don't know what's this shit that's gotten to you. But I don't like it, I really don't. I don't like where this is going, old man!"

"Well," He said, calmly. "you killed El-Fuqer by forcing him to eat his own cock and balls while sowing his ass shut and then took a fat stinking dump on his face." He quietly recalled the, ehem, 'little' incident. "But see, I don't waggle your fucking nutsack about the fucked up shit you've done. And I'm not going to start now."

"THAT'S DIFFERENT! THAT WAS __JUSTICE__!" Her eyes flashed with anger.

"JUSTICE?!! YOU CALL SHITTING ON A CORPSE 'JUSTICE'?!!" He pushed her to the side and stormed out. "I MAY BE AN EVIL WIZARD, BUT I NEVER DEFECATED ON MY ENEMIES, HASHADE. NEVER. FOR FUCKS SAKE!"

"Wait!" Her voice cracked. "You can't just leave like this!"

"I can." He didn't even look back. "And I am."

"I'm not leaving you alone!" She strides closer to him, ignoring the sting of his words. "I can't let you destroy yourself like this!"

(ROGUE BUSTS IN THROUGH THE KITCHEN) "ALRIGHT, ALRIGHT, YOU TWO, GET A ROOM ALREADY!"

~ F I N ~