akrasuski1

That is not enough, since you may still get stuck in a loop.

40 microwatts of power, to be precise. Compared to, say, 5V*1A=5W of typical phone charger, this is impractical by a large margin.

Another nice site aggregating many clever tiny x86 programs: https://www.xorpd.net/pages/xchg_rax/snip_00.html

This could actually be caused by disk caching effects. Have you tried running cloc second time afterwards?

Well, that's why I always define RED(x) (for reduce modulo) as ((((x) % MOD) + MOD) % MOD). Quite useful in algorithmic competitions, which often ask you for answer modulo some prime.

And thus you used a throwaway account...

From the listed words only two have immediately obvious Polish connotations (dźjada (grandpa), and dziadek is grandpa in Polish; śpjelik (sparrow), where śpiewać is "to sing"). Most words have German-ish sound to them, somewhat similar to Silesian subdialect of Polish (though Silesia was occupied by Germany, which is the reason for its influence). The spelling is mostly Polish-like, perhaps from older centuries though; except for some umlauts which clearly originate in German and similar.

Looks like jewellery is popular in language namimng: we've got Ruby, Crystal, now Emerald...

It's done so that the bits will compare the same way whether treated as float or int. (modulo NaNs and stuff)

The decreasing health bar looks like a really weird idea. I don't like to be forced into thinking fast, I prefer to make a clear point even if it takes longer.

Hm, if the example written on README is representative for current usage, then it surely changed a lot recently. I remember checking angr out a few months ago, and simply running a binary required a few dozens of, mostly boilerplate, code. I may try it again now, looks like it improved since then.

I'm pretty sure it doesn't matter whether the eneergy is stored in rotating body, or one moving in a straight line. Kinetic energy of rotation is 0.5 * I * w^2, or for that extreme case of "concrete ring" - 0.5 * m * r^2 * w^2, which is exactly equal to 0.5 * m * v^2, or kinetic energy as calculated for body moving in straight line.

It's really unrelated - it's more about the hash domain being rather small, i.e. 52. I would think that if you substitute the counting (go to card N+value) to proper hashing (go to card md5(value)%52) you would get the same, if not stronger, result.

It is possible to generate a lower bound, so it can be compared with usual numbers, like g_64 etc.

Actually, the mentioned GitList exploit hinges on yet another vulnerability: lack of distinction of command-line flags and arguments. Where user expected to put "normal" name (say a-zA-Z0-9), attacker actually supplied --flag=exploit.

Uhmm... screenshot the mail; self-destruction circumvented.

I wouldn't be surprised if the future compilers would optimize it away as well, since ffast-math basicly makes NaN's equivalent to undefined behaviour.

It would be nice to divide the cooccurence count by counts of respective two headers, to get a sort of correlation. Now it's quite hard to see anything beyond "most popular things are paired with most popular things" which is obvious.

Also see https://holeybeep.ninja/

That is honestly a great idea for safe-ish deprecation in uninformed environment!

Presumably the stackexchange answer is what OP meant by it being an idiom.

Hmm, I guess someone would have thought of that, but this could probably be used for compressing images by reorienting the color axes so that one of them is perpendicular to this color plane, and then sending less information about that coordinate.

There has been some malware that did just that - it was still possible to record the trace of instructions being executed along with the current instruction pointer to be able to reconstruct the binary quite well.

Can anyone explain why these two arrangements are not equivalent? They seem to both cause same phase shift and reflections, but the first one causes the photon to pass to the right, and the second - to split.

https://imgur.com/a/OkEQY

https://imgur.com/a/Byo8E

Vertical and horizontal here seem quite confusing. The absorptive polarizer with vertical lines drawn on it passes through photons passing through PBS, which game calls horizontal. So either the polarizer lines have negative logic (indicating what is absorbed, not passed through), or there is some inconsistency. Similarly, the horizontal polarization is represented as photon bouncing up and down ("vertically") if it travels right. This can get confusing.

I wonder if some polarization arrow can be drawn somehow, like: https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTAlDUU...

I can recommend one of his older flash games: KOHCTPYKTOP. Awesome, about making silicon-level transistors, gates, eventually chips...

Actually, they're not unit. When you type "abcd", then (without exiting insert mode) move left twice and type "xx" (resulting in "abxxcd"), then undoing once will leave you at "abcd".

Using fixed-point representation would allow using this compression method.

Actually, the syscall numbers are wrong! This reference seems better: http://blog.rchapman.org/posts/Linux_System_Call_Table_for_x...

Consider simple C program:

    #define _GNU_SOURCE
    #include <unistd.h>
    
    int main(){
        syscall(276);
    }

That's all cool and everything, but the registers are wrong... Not only are they 32-bit (eax vs. rax), but their order is wrong too - the first argument in x86-64 ABI is rdi, for example.