C++ is std::__cxx11::list<std::__shared_ptr<table, (__gnu_cxx::_Lock_policy)0>, std::allocator<std::__shared_ptr<table, (__gnu_cxx::_Lock_policy)0> > >::erase(std::_List_const_iterator<std::__shared_ptr<table, (__gnu_cxx::_Lock_policy)0> >) /usr/include/c++/12/bits/list.tcc:158
your underflow error is someone’s underflow feature (hopefully with -fwrapv)
that works for 2 word names eg is_open or is_file, but in this case is_dialog_file_open is structured like a question, while dialog_file_is_open is structured like a statement
like everything in python, to achieve functional you must first import functional
as many iterations as it takes
void* x = &x;
char* ptr = (char*)&x;
while (1) {
printf("%d\n", (unsigned int)*ptr);
ptr--;
}
Why would anyone let you stockpile resources they create?
the same reason people let it happen now: people aren’t actually a hivemind where every individual steadfastly holds to your chosen ideology and ceaselessly watches each other and keeps precise track of what everyone is doing. Surveillance states can’t root out crime and black markets, so I very much doubt a loose association of stateless communes can do it either.
That group won’t exist in a vacuum. It needs to be resilient to outside interference. Even inside that group there are going to be people that only identify with it out of convenience rather than true belief. It is still possible for individuals to accrue social capital, form “inner circles” and individually stockpile resources - and stopping them would logically infringe on their freedoms to associate, freedom to dig holes, etc.
It’s just the paradox of tolerance again. Too much freedom causes a power vacuum, which almost inevitably causes some small but determined authoritarian group to gobble up that power until they get so big they can overthrow the whole system. And then you’re back to square one, except now the system is probably fascist.
Considering this was written in 2001, I’m not all that worried
slow inverse square root:
float slowinvsqrt(float x)
{
const long accuracy = 100000000; // larger number = better accuracy
if (x <= 0.0f) {
return NAN;
}
if (x == 1.0f) {
return 1.0f;
}
if (x < 1.0f) {
return 1.0f / slowinvsqrt(1.0f/x);
}
int max_power = log(accuracy) / log(x);
long pow1 = pow(x, max_power - 1);
long pow2 = pow(x, max_power);
double current = 1.0;
double previous = 1.0;
for (long i = 0; i<10*accuracy; i++) {
current = sin(current);
if (i == pow1) {
previous = current;
}
if (i == pow2) {
return current / previous;
}
}
}
I’d think game journalism has been mostly replaced by youtube reviewers / video essays, no?
steam’s drm is a complete joke though? Tons of game developers add their own drm on top because it is so trivial to bypass steam’s own.
Their main product is a marketplace/content delivery system
if all 330 million 'mericans tried living in the woods, shit would go south really quickly
even if you write in assembly, you still may not actually understand what is going on in the machine since processors convert the instructions to “micro-ops”, and let’s not forget hardware bugs like those caused by speculative execution
Oopsie woopsie!
Is there something I should be keeping an eye out for, or preparing for so everything goes smoothly at least with regards to this community?
On the 6th of May, 2028, travel to 2 Augusta Hills Drive, Bakersfield, Kern County, California, United States. At exactly 4 PM local time, place an orange traffic cone on top of the nearest garbage can and await further instructions.
ironically suyu is still up on github
and of course ryujinx hasn’t received any legal threats yet
Youtube actually uses 128kbps opus, which should be significantly better than 160kbps mp3
but the real problem is that you can’t know what quality the uploader used, it all gets recompressed by youtube.
They could do it without recompilation, but something like changing the obfuscation and recompiling for every copy would likely make it much harder to get rid of the watermarks even if you can compare several different copies
(though they could also have multiple watermarked sections so that any group of for example 3 copies would have some section that is identical, but still watermarked and would uniquely identify all three leakers. The amount of data you need the watermarks to contain goes up exponentially with the amount of distinct copies, but if you have say 1000 review copies and want to be resistant to 4 copies being “merged”, you only need to distinguish between 1000^4 combinations so you can theoretically get away with a watermark that only contains about 40 bits of data )
what?