I've been away a while, mostly working 60-70 hour weeks.

Found a managers job and the illusion of low-level stability.

Also been exploring elliptic curve cryptography and other fun stuff, like this fun equation...

i = log(n, 2**0.5)
base = (((int((n/(n*(1-(n/((((abs(int(n+(n/(1/((n/(n-i))+(i+1)))))+i)-(i*2))/1))/1/i)))))*i)-i)+i))

...as it relates to A143975 a(n) = floor(n*(n+3)/3)

Most semiprimes n=pq, where p<q, appear to have values k in the sequence, where k is such that n+m mod k equals either p||q or a multiple thereof.

Tested successfully up to 49 bits and counting. Mostly haven't gone further because of work.

Theres a little more math involved, and I've (probably incorrectly) explained the last bit but the gist is the factorization doesn't turn up anything, *however* trial lookups on the sequence and then finding a related mod yields k instead, which can be used to trivially find p and q.

It has some relations to calculating on an elliptic curve but thats mostly over my head, and would probably bore people to sleep.

Holy smokes, an LLM thats a competent wit.

(it gets good toward the end)

https://pastebin.com/MpGzZRqK

courtesy of https://worldsim.nousresearch.com

edit: I was particularly fond of "Schrodinger's cat mocks causality, simultaneously alive and droll"

Probably pure coincidence but if you look at the deconstruction of the dedekinds like so:

>>> decon(6)
offset: 1, exp: [[Decimal('2'), Decimal('1')], [Decimal('3'), Decimal('1')]]

>>> decon(20)
offset: 2, exp: [[Decimal('2'), Decimal('2')], [Decimal('5'), Decimal('1')]]
offset: 1, exp: []

>>> decon(168)
offset: 3, exp: [[Decimal('2'), Decimal('2')], [Decimal('5'), Decimal('2')]]
offset: 2, exp: [[Decimal('2'), Decimal('2')], [Decimal('3'), Decimal('1')], [Decimal('5'), Decimal('1')]]
offset: 1, exp: [[Decimal('2'), Decimal('3')]]

>>> decon(7581)
offset: 4, exp: [[Decimal('2'), Decimal('3')], [Decimal('5'), Decimal('3')], [Decimal('7'), Decimal('1')]]
offset: 3, exp: [[Decimal('2'), Decimal('2')], [Decimal('5'), Decimal('3')]]
offset: 2, exp: [[Decimal('2'), Decimal('4')], [Decimal('5'), Decimal('1')]]
offset: 1, exp: []

>>> decon(7828354)
offset: 7, exp: [[Decimal('2'), Decimal('6')], [Decimal('5'), Decimal('6')], [Decimal('7'), Decimal('1')]]
offset: 6, exp: [[Decimal('2'), Decimal('8')], [Decimal('5'), Decimal('5')]]
offset: 5, exp: [[Decimal('2'), Decimal('5')], [Decimal('5'), Decimal('4')]]
offset: 4, exp: [[Decimal('2'), Decimal('6')], [Decimal('5'), Decimal('3')]]
offset: 3, exp: [[Decimal('2'), Decimal('2')], [Decimal('3'), Decimal('1')], [Decimal('5'), Decimal('2')]]
offset: 2, exp: [[Decimal('2'), Decimal('1')], [Decimal('5'), Decimal('2')]]
offset: 1, exp: [[Decimal('2'), Decimal('2')]]

>>> decon(d('2414682040998'))
offset: 13, exp: [[Decimal('2'), Decimal('13')], [Decimal('5'), Decimal('12')]]
offset: 12, exp: [[Decimal('2'), Decimal('13')], [Decimal('5'), Decimal('11')]]
offset: 11, exp: [[Decimal('2'), Decimal('10')], [Decimal('5'), Decimal('10')]]
offset: 10, exp: [[Decimal('2'), Decimal('11')], [Decimal('5'), Decimal('9')]]
offset: 9, exp: [[Decimal('2'), Decimal('9')], [Decimal('3'), Decimal('1')], [Decimal('5'), Decimal('8')]]
offset: 8, exp: [[Decimal('2'), Decimal('10')], [Decimal('5'), Decimal('7')]]
offset: 7, exp: [[Decimal('2'), Decimal('7')], [Decimal('5'), Decimal('6')]]
offset: 6, exp: []
offset: 5, exp: [[Decimal('2'), Decimal('6')], [Decimal('5'), Decimal('4')]]
offset: 4, exp: []
offset: 3, exp: [[Decimal('2'), Decimal('2')], [Decimal('3'), Decimal('2')], [Decimal('5'), Decimal('2')]]
offset: 2, exp: [[Decimal('2'), Decimal('1')], [Decimal('3'), Decimal('2')], [Decimal('5'), Decimal('1')]]
offset: 1, exp: [[Decimal('2'), Decimal('3')]]

the powers in the 2's column go:
1, 2, 2, 2, 3, 3, 2, 4, 6

which are predicted by:
https://oeis.org/search/...

Again, probably only a coincidence, but kinda beautiful.

Writing a full interpreter for a pseudo-assembly language.

It's kinda fun but the things a bit of a cunt of a problem because I only did this once before almost a decade and a half ago.

getting just the right format and deciding on the syntax is a slog. Just need something thats quick and sufficiently expressive because I'm not writing the assembly myself, I'm generating the assembly code that runs through the interpreter, so it has to be valid under a lot of conditions.

So I promised a post after work last night, discussing the new factorization technique.

As before, I use a method called decon() that takes any number, like 697 for example, and first breaks it down into the respective digits and magnitudes.

697 becomes -> 600, 90, and 7.

It then factors *those* to give a decomposition matrix that looks something like the following when printed out:

offset: 3, exp: [[Decimal('2'), Decimal('3')], [Decimal('3'), Decimal('1')], [Decimal('5'), Decimal('2')]]

offset: 2, exp: [[Decimal('2'), Decimal('1')], [Decimal('3'), Decimal('2')], [Decimal('5'), Decimal('1')]]

offset: 1, exp: [[Decimal('7'), Decimal('1')]]

Each entry is a pair of numbers representing a prime base and an exponent.

Now the idea was that, in theory, at each magnitude of a product, we could actually search through the *range* of the product of these exponents.

So for offset three (600) here, we're looking at

2^3 * 3 ^ 1 * 5 ^ 2.

But actually we're searching

2^3 * 3 ^ 1 * 5 ^ 2.
2^3 * 3 ^ 1 * 5 ^ 1
2^3 * 3 ^ 1 * 5 ^ 0
2^3 * 3 ^ 0 * 5 ^ 2.
2^3 * 3 ^ 1 * 5 ^ 1

etc..

On the basis that whatever it generates may be the digits of another magnitude in one of our target product's factors.

And the first optimization or filter we can apply is to notice that assuming our factors pq=n,
and where p <= q, it will always be more efficient to search for the digits of p (because its under n^0.5 or the square root), than the larger factor q.

So by implication we can filter out any product of this exponent search that is greater than the square root of n.

Writing this code was a bit of a headache because I had to deal with potentially very large lists of bases and exponents, so I couldn't just use loops within loops.

Instead I resorted to writing a three state state machine that 'counted down' across these exponents, and it just works.

And now, in practice this doesn't immediately give us anything useful. And I had hoped this would at least give us *upperbounds* to start our search from, for any particular digit of a product's factors at a given magnitude. So the 12 digit (or pick a magnitude out of a hat) of an example product might give us an upperbound on the 2's exponent for that same digit in our lowest factor q of n.

It didn't work out that way. Sometimes there would be 'inversions', where the exponent of a factor on a magnitude of n, would be *lower* than the exponent of that factor on the same digit of q.

But when I started tearing into examples and generating test data I started to see certain patterns emerge, and immediately I found a way to not just pin down these inversions, but get *tight* bounds on the 2's exponents in the corresponding digit for our product's factor itself. It was like the complications I initially saw actually became a means to *tighten* the bounds.

For example, for one particular semiprime n=pq, this was some of the data:

n - offset: 6, exp: [[Decimal('2'), Decimal('5')], [Decimal('5'), Decimal('5')]]

q - offset: 6, exp: [[Decimal('2'), Decimal('6')], [Decimal('3'), Decimal('1')], [Decimal('5'), Decimal('5')]]

It's almost like the base 3 exponent in [n:7] gives away the presence of 3^1 in [q:6], even
though theres no subsequent presence of 3^n in [n:6] itself.

And I found this rule held each time I tested it.

Other rules, not so much, and other rules still would fail in the presence of yet other rules, almost like a giant switchboard.

I immediately realized the implications: rules had precedence, acted predictable when in isolated instances, and changed in specific instances in combination with other rules.

This was ripe for a decision tree generated through random search.

Another product n=pq, with mroe data
q(4)
offset: 4, exp: [[Decimal('2'), Decimal('4')], [Decimal('5'), Decimal('3')]]

n(4)
offset: 4, exp: [[Decimal('2'), Decimal('3')], [Decimal('3'), Decimal('2')], [Decimal('5'), Decimal('3')]]

Suggesting that a nontrivial base 3 exponent (**2 rather than **1) suggests the exponent on the 2 in the relevant
digit of [n], is one less than the same base 2 digital exponent at the same digit on [q]

And so it was clear from the get go that this approach held promise.

From there I discovered a bunch more rules and made some observations.
The bulk of the patterns, regardless of how large the product grows, should be present in the smaller bases (some bound of primes, say the first dozen), because the bulk of exponents for the factorization of any magnitude of a number, overwhelming lean heavily in the lower prime bases.

It was if the entire vulnerability was hiding in plain sight for four+ years, and we'd been approaching factorization all wrong from the beginning, by trying to factor a number, and all its digits at all its magnitudes, all at once, when like addition or multiplication, factorization could be done piecemeal if we knew the patterns to look for.

I didn't leave, I just got busy working 60 hour weeks in between studying.

I found a new method called matrix decomposition (not the known method of the same name).

Premise is that you break a semiprime down into its component numbers and magnitudes, lets say 697 for example. It becomes 600, 90, and 7.

Then you break each of those down into their prime factorizations (with exponents).
So you get something like

>>> decon(697)
offset: 3, exp: [[Decimal('2'), Decimal('3')], [Decimal('3'), Decimal('1')], [Decimal('5'), Decimal('2')]]
offset: 2, exp: [[Decimal('2'), Decimal('1')], [Decimal('3'), Decimal('2')], [Decimal('5'), Decimal('1')]]
offset: 1, exp: [[Decimal('7'), Decimal('1')]]

And it turns out that in larger numbers there are distinct patterns that act as maps at each offset (or magnitude) of the product, mapping to the respective magnitudes and digits of the factors.

For example I can pretty reliably predict from a product, where the '8's are in its factors.

Apparently theres a whole host of rules like this.
So what I've done is gone an started writing an interpreter with some pseudo-assembly I defined. This has been ongoing for maybe a month, and I've had very little time to work on it in between at my job (which I'm about to be late for here if I don't start getting ready, lol).

Anyway, long and the short of it, the plan is to generate a large data set of primes and their products, and then write a rules engine to generate sets of my custom assembly language, and then fitness test and validate them, winnowing what doesn't work.

The end product should be a function that lets me map from the digits of a product to all the digits of its factors.

It technically already works, like I've printed out a ton of products and eyeballed patterns to derive custom rules, its just not the complete set yet. And instead of spending months or years doing that I'm just gonna finish the system to automatically derive them for me. The rules I found so far have tested out successfully every time, and whether or not the engine finds those will be the test case for if the broader system is viable, but everything looks legit.

I wouldn't have persued this except when I realized the production of semiprimes *must* be non-eularian (long story), it occured to me that there must be rich internal representations mapping products to factors, that we were simply missing.

I'll go into more details in a later post, maybe not today, because I'm working till close tonight (won't be back till 3 am), but after 4 1/2 years the work is bearing fruit.

Also, its good to see you all again. I fucking missed you guys.

God damn, the most beautiful thing I've read in probably two years. It *moved* me.

https://fortressofdoors.com/four-ma...

Good to see you all.

I love them shitty scammy singles dating ads.

"Hot Single Volcanos Are Looking For Dates In Your Area."

And

"once you play this game, your friends won't be seeing much of you!"

Also merry chrysler!

I turned down another women who was absolutely, 100% flirting with me, because, from what I can gather, she was trying to get out of a relationship with her current boyfriend, a military veteran.

I outright ignored her and then when that failed, I made our work relationship 100% about that, work.
Even though I'm friendly with everyone else.

I'm an absolute shit, aren't I? I feel genuinely bad.
I'm not sure if I did it out of a misplaced sense of honor for a dude who obviously has some ptsd, or because I don't feel like I'm able to connect with anyone anymore.

I feel like I'm alone in this world. Not, like, sexually or anything, but more like I don't want to burden anyone with the shit I'm going through. Like a man on a mission on a sinking ship, and it would be wrong to let anyone else on board.
Like a one-man shit-show, all singing, all dancing, driven to one end, with one purpose. And it'd be wrong to let anyone get attached, or invite anyone else in.

Fuck I got so many irons in the fire. I have an ARG in the works, a full game, a social platform that the code and marketing plan is laid out and I'm saving money for, two more games already planned, plus spending an in-ordinate amount of time with my father and sister and mother as they deal with the loss of my sister, plus volunteering to help the homeless, plus working, plus studying.

I barely sleep.

It's just me. I'm like a cruise missile heading to one destination, to some final destination, I just don't know what. And I don't let anyone in, because then they might see how fucking crazy I am, and how crazy my life is, and how crazy my goals are. Thats not a humblebrag. Thats more of a "wholly shit, I'm so in over my head, I'm fucking drowning" type thing. But I'm not giving up, I'm just going deeper.

And it feels like drowning but somehow I'm okay with it. Like I've passed the crux of loneliness, and settled for going for it all, alone, shooting out of orbit, and saying "fuck it all' to everything and everyone. They say "if you got everything you wanted, everything you wished for, you'd wish you hadn't, which is why god isn't a genie". And lately I've been thinking god doesn't exist, or doesn't care, because he's left it all up to me, and I've fucked it up good and proper, and am on my way to either nothing, or everything I've ever wanted.

Is this what happiness feels like? Or suicide?

I don't know. I mean I really don't. I don't want to die. I think I could stop existing and be okay with it. Having achieved at least a modicum of understanding the universe, at least accomplished something small but meaningful.
Or maybe I'm delusional, driven mad with the full comprehension of human floundering against a meandering existence.

I don't fucking know.

I feel like I'm spinning my wheels, so much, that even two weeks feels like a fucking eternity. I don't sleep anymore. When I do, I escape into my dreams, where I can fly, or float, and the people in my dreams tell me I'm living in the matrix and I believe them..in my dreams. Feel it even.

And when I wake up, the feeling persists. Leaves me in wonderland, for hours after waking.

And I have visions, of going homeless, like some buddha, all the time, and then I say "wake up J, you're fucking crazy! You want to go be some couch surfing homeless bum living off other's good graces? get the fuck outa here! While others suffer, schlep it at whatever job they work, day in day out, toil. In this economy? In this inflation? What a dishonest way of thinking. What a dishonest way of dreaming."

And yet I daydream. Because its the only escape there is from all the world has become.

And I bring joy to others, earnestly, vicariously, because its the closest joy I can feel, when I've become numb.

It is this quasi-permanent sense of alienation that permeates my whole world, a sort of invisible force field that separates me from others, even as I reach out to understand them, to comfort them, to smooth the corners off their world, so that they don't become like I have, something not entirely human, but...other.

Often when we meditate, long and hard enough,
at the center that emerges, at the center of ourselves, we find an abyss, a whole universe, devoid of anything, a perfect silence, mirroring back the cosmos, and other people. Observing, silent, irreducible, implacable.

Sometimes I feel like I don't exist. Sometimes I think others don't exist.

Very often I feel like nothing is real. And that I am playing some sort of game. Not like a video game per se, but that there is a bigger pattern, a hidden pattern to it all, just out of reach, and I'm reaching for it but understanding eludes me.

Not that the universe has made me for some special purpose, but merely that the universe observes me specifically, for no special purpose, other than that it can, whatever trivialities may impede or push forward my life.

As if the universe were bored.

I just finished designing an entire asset management pipeline and christ on a fucking pogo stick, if it isn't convoluted.

Theres a lot of game engines out there, but all of them do it a little different. They all tackle a slightly different problem, without even realizing it.

1. asset management

2. asset change management

3. behavior change management

4. data management

5. combinatorial design management.

6. Combinatorial Behavior management

7. Feature completion

ASSET MANAGEMENT is exactly what it says on the tin.

ASSET CHANGE management can be thought of handling the import, export, formatting, platform specific packing, and versioning (including forking) of an asset.

BEHAVIORAL CHANGE management is a subset of asset management, because code is a subset of assets (depending on how you define 'assets'). The oldest known example of this is commenting and uncommenting code.
Or worse, printf debugging.

This can be file versioning, basic undo services, graph management of forks and mergers, toggles for features or modules, etc.

DATA management is about anything that doesn't fall into the other categories, everything from mission text to npc dialogues, quests, location names, item stats, the works. Anything you'd be tempted to put in a database, falls under this category. Haven't yet seen many engines offer this as an explicit built in tool as of yet, because the other problems are non-trivial as is, so this is a bit of low hanging fruit that gets handled by external tools, or loaded from formats as simple as json.

COMBINATORIAL DESIGN management is the idea of prefabbing, blueprints of broader object design using nested prototypes of existing game objects, to create more complex, reusable set pieces. Unity did this well. GM does this in part.

COMBINATORIAL BEHAVIOR management is entity-component systems, plus tooling to make it easy to add, remove, and configure components and their values on entity blueprints, also not uncommon. Both stencyl and unity do this. GM has a precursor to this in the form of configurable fields, but these fields are not based on component scripts attached to objects.

FEATURE COMPLETION is that set of gameplay mechanics or styles of design that an engine naturally makes easier to include or build in a game.

I don't think I'm aiming for all that, but I think at minimum a good engine has to do asset management, behavioral change management, prefabs, and entity-component systems with management tools for that. And ideally, asset change management.

Ideas:

1. Scrape github

2. Attach feature size estimate (an abstract scale) as examples across many projects.

3. Use this as prompt/finetunning data.

4. Train and prompt on project descriptions relative to feature size and number of contributors/changes in the changelog.

5. Package and release a model that takes descriptions of ideas and generates reasonable estimates of time and manpower.

6. Optional, sell as an estimate service to corporate and make money introducing some sanity to the world for a change.

v0.0005a (alpha)
- class support added to lua thanks to yonaba.
- rkUIs class created
- new panel class
- added drawing code for panel
- fixed bug where some sides of the UI's border were failing to drawing (line rendering quark)

v0.0014a (alpha) 11.30.2023 (~2 hours)
- successfully retrieving basic data from save folder, load text into lua from files
- added 'props' property to Entity class
- added a props table to control what gets serialized and what doesn't
- added a save() base method for instances (has to be overridden to be useful beyond the basics)
- moved the lume.serialize() call into the :save() method on the base entity class itself
- serialized and successfully saved an entities property table.
- fixed deserializion bugs involving wrong indexes (savedata[1] not savedata[2])
- moved deserialization from temp code, into line loading loop itself (assuming each item is on one line)
- deser'd test data, and init()'d new player Entity using the freshly-loaded data, and displayed the entity sprite

All in all not a bad session. Understanding filing handling and how to interact with the directory system was the biggest hurdle I was worried about for building my tools.

Next steps will be defining some basic UI elements (with overridable draw code), and then loading and initializing the UI from lua or json.

New projects can be set as subfolders folders in appdata, using 'Setidentity("appname/projectname") to keep things clean.

I'm not even dreading writing basic syntax highlighting!

Idea is to dogfood the whole process. UI is in-engine rendered just like you might see with godot, unity, or gamemaker, that way I have maximum flexibility to style it the way I want. I'm familiar enough with constructing from polygons, on top of stenciling, on top of nine-slicing, on top of existing tweening and special effects, that I can achieve exactly what I want.

Idea is to build a really well managed asset pipeline. Stencyl, as 'crappy' as it appeared, and 'for education' was a master class in how to do things the correct way, it was just horribly bloated while doing it.

Logical tilesets that you import, can rearrange through drag-n-drop, assign custom tile shapes to, physics materials, collisions groups, name, add tag data to, all in one editor? Yes please.
Every other 2D editor is basic-bitch, has you importing images, and at most generates different scales and does the slicing for you.

Code editor? Everything behavior was in a component, with custom fields. All your code goes into a list of events, which you can toggle on and off with a proper toggle button, so you can explicitly experiment, instead of commenting shit out (yes git is better, but we're talking solo amateurs here, they're not gonna be using git out the gate unless they already know what they're doing).

Components all have an image assignable to identify them, along with a description field, and they're arranged in a 2d grid for easy browsing, copying, modifying.

The physics shape editor, the animation editor, the map editor, all of it was so bare bones and yet had things others didn't.

I want that, except without the historic ties to flash, without the overhead of java, and with sexier fucking in-engine rendering of the UI and support for modding and in-engine custom tools.

Not really doing it for anyone except myself, and doubt I'll get very far, but since I dropped looking for easy solutions, I've just been powering through all the areas I don't understand and doing the work.

I rediscovered my love of programming after 3-4 years of learning to hate it, and things are looking up.

heres a new constant found this morning

>>> (1.39094974939078**(pi-0.5))-1.39094974939078
==
0.9999999999999867

the following..
>>> 1.39094974939078**2
1.934741205330274 +/- 1

and

((1.39094974939078**(pi-0)))
2.8198510518716056 +0/+1/+1

show up in things as varied as the density of galaxies, gasoline chemistry, traffic accident formulas, and more.

Kinda cool.

You know pipeless, what this site is built on, actually looks like a pretty cool platform to work with.

Anyone used it? What was your experience?

(every time I end a post on questions like these, it always ends up *crickets*).

highly relevant microservices rant:
https://youtube.com/watch/...

Couldn't be arsed with all the conditional compilation that angelscript required, so I dumped right back to good ol' lua for now.

Got lua in, vm started, loading strings and pushing/popping the stack.

Got SDL actually drawing as intended.

I don't know even half of what I'm doing.
Apparently header files that end in ".hpp" are specific to c++, while .h are for c headers.

I like the new SDL2 though, little bit different than SDL1. Not a lot of tutorials cover the difference, but I could kinda suss out from the documentation where I needed to adapt, even though I'm still pretty loose on the library, on the docs, and on c++ itself.

Still just a learning project.

Also, I'm continually surprised there isn't a portable, platform independent tool or little language just for replacing all pseudo-languages out there like .bat and .sh, and .zsh

Maybe even just a tool that standardizes it all, then takes config files that map the new standard to system dependant commands, so you can download the damn thing, configure the relevant environment variables, drop in the platform dependent configuration (or your browser or package tool detects what platform you are on and chooses the relevant package/download for your platform), write a console script and the tool automatically translates, and emits the system-relevant commands to that platform's console (so you don't even need much platform-specific code to do things like file access).

Got VS running, SDL up and running and outputting, and angelscript included. Only getting linker errors on angel at the moment, not on inclusion, but on calling engine initialization.
Who knows what it is. Devs recommended precompiling but I wanted to compile with the project rather than as a dll (maybe I'm doing something stupid though, too new to know).

Goal is to do for sdl, cpp, and angelscript, what LOVE2d did for lua. Maybe half baked, and more just an experiment to learn and see if I can.

Would be cool to script in cpp without having to fuck with compilers and IDEs.

As simple as 1. write c++, 2. script is compiled on load, 3. have immediate access to sdl in the same language that the documentation and core bindings are written for.

Maybe make something a little more batteries-included than what lua and love offer out of the box, barebones editors and tooling and the like, but thats off in the near future and just a notion rather than a solid plan.

Needed to take a break from coding my game and here I am..experimenting with more code.

Something is wrong with me.

Bit the bullet and installed VS and relevant compilers for C++ and started fucking around with sdl.

Not as terrible as I thought it was going to be.
Pointers seem pretty intuitive. Apparently my time with python has not in fact mentally mutilated me.

Exploring dedekinds and kronecker products (script at - https://pastebin.com/dDuT3dTp)

and the thing I immediately notice, if you output the matrix is that it is a lower triangular matrix. I don't know a lot about the kronecker or matrices in general, but if dedekinds can be generated in this manner, shouldn't some standard approaches like back substitution or forward substitution be applicable here or am I off in left field on this?

I'm just saying, trimming and pruning fruit trees changes a man.

For you rust programmers out there:
10k bounty for improvements to prettier.

details here:

https://twitter.com/Vjeux/status/...

Any of you on prozac? My sister in Nevada was prescribed it a few years back and never took it because she was nervous and had heard bad things about it.

Shes been a manic depressive her whole life, and has always been anxious about every little thing since we were kids.

What was your experience with prozac if any?

3 straight days with less than 3 hours of sleep per night. If something or someone wakes me in the first fifteen minutes as I'm drifting off, that's it, my wired for however long.

Previous two nights I just barely slept at all. Last night got awakened twice as I was drifting off. To start with, its ettypre for me to be able to fall asleep at all a second time.

Last three nights I'm not actually sure I even slept. I blinked and it was morning and I woke up exhausted. Only thing I can remember is racing thoughts, as I fell asleep, and the very same exact thoughts *as* I woke up, as if my brain had been thinking the same thing on a loop for a few hours, while I was catatonic and unable to fully shut down, stuck in 'on' mode all night and not realizing it.

Not a single fucking job I work honor's their god damn promises, let alone my repeated requests for night shift.

Was so exhausted yesterday my chest hurt.

How am I supposed to drive to work on less than 9 hours asleep spread out across three days? Cant catch a fuckong break lately, and when I do it's like the universe fucking sabotages me with shit like this.

So someone posted their btc wallet details (system automated message through a custom tool) to a paste in alternative.

Was the login for an ssh. Wont confirm or deny ssh-ing into it, but another guy who saw the same thing messaged me, sent a screenshot. Account had 127k usd worth of btc in it.

Called the radio station it belonged to and gave them a heads up. Probably should reported it as well but people already seen it so it'll get taken down soon enough.

Here I am broke, busting my ass and reality throws this in my lap. But I ain't never been no god damn thief. Hope the radio station it belongs to doesnt get robbed by someone less honest though.

Honesty is probably half the reason I've spent half my life broke trying to find or make opportunities.

And frankly I've heard real horror stories of good faith reports (whitehat style pentesting, etc) and the people that report it get fucked hard by authorities. What can you do though.

Enough navel gazing though.
What the fuck is wrong with the people who build these sort of account reset tools anyway?

The fact that four to eight dollars a week could break me and cause me to lose my job before I've even started is a statement on how bad the american economy is, and what kind of future people have in america: none.

There is none.

C# isn't simply garbage collected.

C# is garbage. Hot garbage that needs to be collected.

Bold and brash? More like belongs in the trash!

In other news I'm now making $20+ an hour ($16 after taxes) turning bolts for a living. Fucking bolts.

More money than I ever made in my life before.
I don't know if this should be a happy statement or a sad one.

The minimum wage in 1963 worked out to 23 dollars an hour, so hey, I can't be doing too bad.

True story:
I haven't known a lot of them, but everyone I ever met who had an obsession with designer chairs, was a psychopath.

Like a legit psychopath.

also, these are some mighty fine chairs.
mighty. fine. chairs I tells ya.

https://ex-astris-scientia.org/data...

Why aren't we designing robot grippers the way fractal vices are designed?

When we subtract some number m from another number n, we are essentially creating a relationship between n and m such that whatever the difference is, can be treated as a 'local identity' (relative value of '1') for n, and the base then becomes '(base n/(n-m))%1' (the floating point component).

for example, take any number, say 512
697/(697-512)
3.7675675675675677

here, 697 is a partial multiple of our new value of '1' whose actual value is the difference (697-512) 185 in base 10. proper multiples on this example number line, based on natural numbers, would be
185*1,
185*2
185*3, etc

The translation factor between these number lines becomes

0.7675675675675677

multiplying any base 10 number by this, puts it on the 1:185 integer line.

Once on a number line other than 1:10, you must multiply by the multiplicative identity of the new number line (185 in the case of 1:185), to get integers on the 1:10 integer line back out.

185*0.7675675675675677 for example gives us

185*0.7675675675675677
142.000000000000

This value, pulled from our example, would be 'zero' on the line.

185 becomes the 'multiplicative' identity of the 1:185 line. And 142 becomes the additive identity.

Incidentally the proof of this is trivial to see just by example. if 185 is the multiplicative identity of 697-512, and and 142 is the additive identity of number line 1:185

then any number '1', or k=some integer, (185*(k+0.7675675675675677))%185
should equal 142.

because on the 1:10 number line, any number n%1 == 0

We can start to think of the difference of any two integers n, as the multiplicative identity of a new number line, and the floating point component of quotient of any number n to the difference of any number n-m, as the additive identity.

let n =697
let m = 185
n-m == '1' (for the 1:185 line)

(n-m) * ((n/(n-m))%1) == '0'

As we can see just like on the integer number line, n%1 == 0
or in the case of 1:185, it equals 142, our additive identity.

And now, the purpose of this long convoluted post: all so I could bait people into reading a rant on division by zero.

Out mowing lawns for cash today.
If anyone has a Bush that needs trimmed, I got you.

I also make landing strips for a living, and am a professional at matching drapes with carpets.